Python实战：四种Redis部署模式（单机/主从/哨兵/集群）的连接方式详解

我们之前介绍过单机、主从、哨兵、集群这几种不同的 Redis 部署方式，它们的连接方式自然也不一样。本小节将使用 Python 代码，具体演示程序应如何连接这几种模式下的 Redis。为了示例简单明了，所有的配置信息都将直接写在代码里。

环境准备与依赖安装

在开始编写连接代码之前，需要确保环境已经安装了必要的 Python 库。如果你使用的是 CentOS 等基于 yum 的系统，可以按以下步骤操作：

# 安装pip
yum -y install python-pip
# 安装依赖，这个版本才支持低版本的redis
pip install redis==3.5.3
# 如果需要连接集群
pip install redis-py-cluster

单机 Redis 连接

单机部署是最基础的模式，连接方式也最为直接。你可以通过 redis.Redis 类指定主机、端口等信息进行连接。

# coding: utf-8
import redis

# 基础连接
redis_client = redis.Redis(
    host='localhost',
    port=6379,
    db=0,
    password=None,  # 如果有密码
    decode_responses=True  # 自动解码返回字符串
)

# 测试连接
try:
    redis_client.ping()
    print("单机Redis连接成功")
except Exception as e:
    print("连接失败:", str(e))

# 基本操作示例
redis_client.set('key', 'value')
value = redis_client.get('key')
print(value)

运行上述代码，如果连接成功，你将在终端看到类似下图的输出：

主从 Redis 连接

在主从架构中，如果你不需要读写分离，那么可以像连接单机一样，只连接主节点进行所有操作。

如果你需要实现读写分离（写主库，读从库），则需要分别初始化主节点和从节点的客户端。

import redis

master = redis.Redis(host='192.168.31.196', port=6379)
slave = redis.Redis(host='192.168.31.197', port=6379)

print("Redis Master-Slave Test")
print("Master: 192.168.31.196:6379")
print("Slave: 192.168.31.197:6379")
print("-" * 30)

# Write to master
print("1. Write to master...")
master.set('test_key', 'test_value')
print("Write success: key=test_key, value=test_value")

# Read from slave
print("\n2. Read from slave...")
result = slave.get('test_key')
if result:
    print("Read success: %s" % result)
else:
    print("Read failed")

print("\n3. Test complete")

这段代码演示了向主节点写入数据，并从从节点读取，运行结果如下：

哨兵模式连接

在哨兵模式下，你的代码不直接连接 Redis 实例，而是连接哨兵节点。哨兵会告诉你当前的主节点是哪个，即使发生了主从切换，客户端也能自动感知到新的主节点，从而保证写入操作的连续性。

# -*- coding: utf-8 -*-
import redis
from redis.sentinel import Sentinel
import time

# 哨兵配置
sentinel = Sentinel([
    ('192.168.31.196', 26379),
    ('192.168.31.197', 26379)，
    ('192.168.31.197', 26379)
])
print("Redis哨兵写入测试")
print("=" * 40)
try:
    # 第一次写入
    print("第一次写入...")
    master = sentinel.master_for('mymaster', decode_responses=True)
    master_info = sentinel.discover_master('mymaster')
    print("当前主节点: %s:%s" % (master_info[0], master_info[1]))

    master.set('test_key', 'value1')
    print("写入: test_key=value1")

    # 等待30秒
    print("\n等待30秒...")
    for i in range(30):
        time.sleep(1)
        if (i+1) % 10 == 0:
            print("已等待 %d 秒" % (i+1))

    # 第二次写入
    print("\n第二次写入...")
    master = sentinel.master_for('mymaster', decode_responses=True)
    new_master_info = sentinel.discover_master('mymaster')
    print("当前主节点: %s:%s" % (new_master_info[0], new_master_info[1]))

    # 检查是否切换
    if master_info != new_master_info:
        print("主节点已切换!")
        print("原主节点: %s:%s" % (master_info[0], master_info[1]))
        print("新主节点: %s:%s" % (new_master_info[0], new_master_info[1]))
    else:
        print("主节点未切换")

    master.set('test_key', 'value2')
    print("写入: test_key=value2")

    # 显示最终数据
    value = master.get('test_key')
    print("最终数据: test_key=%s" % value)

    print("\n测试完成!")

except Exception as e:
    print("\n错误: %s" % str(e))
    print("请检查哨兵配置和连接")

这个脚本会在两次写入之间等待30秒，模拟故障切换的时间窗口。如果在此期间哨兵完成了主节点切换，客户端将自动连接到新的主节点，如下图所示：

集群模式连接

Redis 集群模式将数据分散在多个节点上，客户端需要使用专门的 RedisCluster 类进行连接。初始化时只需要提供一个集群节点地址，客户端便能自动发现整个集群的拓扑。示例中为了演示键的槽位分布，我们模拟了三个节点的集群。

# -*- coding: utf-8 -*-
from rediscluster import RedisCluster
import redis

# 连接到集群
rc = RedisCluster(
    startup_nodes=[{"host": "127.0.0.1", "port": 7001}],
    decode_responses=True,
    skip_full_coverage_check=True
)

print("Redis集群槽位分布测试")
print("=" * 50)

# 测试几个键
test_data = {
    "user:1": "Alice",
    "user:100": "Bob",
    "user:1000": "Charlie",
    "order:1": "Order1",
    "order:100": "Order100",
    "item:A": "ItemA",
    "item:Z": "ItemZ"
}

print("\n键的槽位分布:")
print("Key\t\t\tSlot\tNode")
print("-" * 40)

for key, value in test_data.items():
    rc.set(key, value)

    # 获取槽位
    r = redis.Redis(host='127.0.0.1', port=7001, decode_responses=True)
    slot = r.execute_command('CLUSTER KEYSLOT', key)

    # 判断节点
    if 0 <= slot <= 5460:
        node = "7001"
    elif 5461 <= slot <= 10922:
        node = "7002"
    else:
        node = "7003"

    print("%-15s\t%5d\t%s" % (key, slot, node))

print("\n" + "=" * 50)
print("槽位范围:")
print("7001: 0 - 5460")
print("7002: 5461 - 10922")
print("7003: 10923 - 16383")

运行后，你会看到不同的键根据其计算出的哈希槽，被分配到了不同的集群节点上，这正是 Redis 集群实现数据分片的核心机制。

总结

通过以上四种模式的 Python 代码示例，我们可以清晰地看到不同 Redis 部署架构下客户端的连接差异：单机和简单主从模式连接最为直接；哨兵模式需要通过哨兵获取主节点，以实现高可用；集群模式则需要使用专用客户端库，由客户端处理数据分片和节点路由。

在实际生产环境中，配置信息通常会放在配置文件或环境变量中，而非硬编码在代码里。掌握这些基础连接方式，是构建稳定可靠的后端应用的关键一步。希望这篇实战指南能帮助你更好地理解和使用 Redis。如果你在实践中有更多心得或问题，欢迎到 云栈社区 交流讨论。