主从redis部署(docker)

Posted 2023-04-23 Aeons

首先，我准备了两台linux，一台准备当作master，ip是192.168.241.128，另一台是当作slave，ip是192.168.241.129。

1. 安装redis

docker pull redis

2. 下载对应版本的redis.conf

可以从github上下载。新建配置环境目录和持久化数据目录。

mkdir -p /home/redis/data
mkdir -p /home/redis/conf
mkdir -p /home/redis/log

修改配置redis.conf:

logfile "/log/redis.log"
dir /data

将redis.conf放到mkdir -p /home/redis/conf下。

3. 创建redis容器

docker run --restart=always --log-opt max-size=100m --log-opt max-file=2 -p 6379:6379 --name redis -v /home/redis/data:/data -v /home/redis/conf/redis.conf:/etc/redis/redis.conf -v /home/redis/log/redis.log:/log/redis.log -d redis redis-server /etc/redis/redis.conf  --appendonly yes 

创建容器后，调用redis-server启动用挂载的路径的redis.conf启动。并且开启AOF持久化。

docker ps -a 查看，发现已成功启动。

如果报这个错：Can\'t open the log file: Is a directory，可能得手动建一个空文件 /home/redis/log/redis.log

4. 创建第二个redis容器

和上面的1，2，3步骤一样，在第二台linux服务器上创建第二个redis。稍微不同的是，在第2个步骤配置redis.conf时，要做修改。

redis.conf加上配置:

192.168.241.128 是我上面配置的第一台linux的地址，意思是第二台是第一台的slave库

slaveof 192.168.241.128 6379

依样部署好第二台redis就可以了。

5. 验证

在redis客户端中执行命令info replication

128(主):

> info replication
# Replication
role:master
connected_slaves:1
slave0:ip=192.168.241.129,port=6379,state=online,offset=0,lag=0
master_failover_state:no-failover
master_replid:8fade8b7a32d08413701d8816661604e773c6cd3
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:0

129(从):

> 192.168.241.129@6379 connected!
> info replication
# Replication
role:slave
master_host:192.168.241.128
master_port:6379
master_link_status:up
master_last_io_seconds_ago:5
master_sync_in_progress:0
slave_read_repl_offset:14
slave_repl_offset:14
slave_priority:100
slave_read_only:1
replica_announced:1
connected_slaves:0
master_failover_state:no-failover
master_replid:8fade8b7a32d08413701d8816661604e773c6cd3
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:14
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:14

很明显，一个role 是master，一个是slave。

验证一下数据同步:

一开始129尝试get "h" ，发现数据不存在。想要写入，因为是从节点，所以提示无法写入。

然后我们往128加入"h"->"hello", 切换到129发现这条数据已经同步过来了，接着128删除这个键，129也是跟着删除了数据。

redis集群之sentinel

1.1 实验说明

　　1、环境说明

　　　　　　1. 前提：本试验环境已经提前安装了docker和docker-compose

　　　　　　2. 说明：本次部署是单机伪集群，想要部署真正的集群，需要将秒个主件拆分到各个机器上去部署，只修改ip地址

　　2、redis三种集群

　　　　　　1. 主从（主从同步原理）

　　　　　　2. sentinel（哨兵模式）

　　　　　　3. codis

　　　　　　详细内容请参考：https://www.cnblogs.com/jiaxinzhu/p/12507605.html

1.2 使用docker-compose部署sentinel

　　1、参考博客

　　　　　　docker-compose部署：https://www.cnblogs.com/boshen-hzb/p/10471665.html

　　　　　　普通部署：https://www.cnblogs.com/kevingrace/p/9004460.html

　　2、使用docker-compose部署

redis-sentinel                        # 项目根路径
    ├── docker-compose.yml            # docker-compose文件
    └── sentinel                      # 存放初始化sentinel容器的相关文件
        ├── Dockerfile                # sentinel构建镜像文件
        ├── sentinel.conf             # sentinel配置文件
        └── sentinel-entrypoint.sh    # sentinel.sh启动脚本

master:
  image: redis
  command: redis-server --port 6379 --requirepass 123456 --masterauth 123456
  ports:
    - "6379:6379"
slave1:
  image: redis
  command: redis-server --slaveof redis-master 6379 --requirepass 123456 --masterauth 123456
  links:
    - master:redis-master
  ports:
    - "6380:6379"
slave2:
  image: redis
  command: redis-server --slaveof redis-master 6379 --requirepass 123456 --masterauth 123456
  links:
    - master:redis-master
  ports:
    - "6381:6379"
sentinel1:
  build: sentinel
  environment:
    - SENTINEL_DOWN_AFTER=5000
    - SENTINEL_FAILOVER=5000    
  links:
    - master:redis-master
    - slave1
  ports:
    - "26379:26379"
sentinel2:
  build: sentinel
  environment:
    - SENTINEL_DOWN_AFTER=5000
    - SENTINEL_FAILOVER=5000    
  links:
    - master:redis-master
    - slave2
  ports:
    - "26380:26379"

redis-sentinel/docker-compose.yml

FROM redis

EXPOSE 26379
ADD sentinel.conf /etc/redis/sentinel.conf
RUN chown redis:redis /etc/redis/sentinel.conf
COPY sentinel-entrypoint.sh /usr/local/bin/
RUN chmod +x /usr/local/bin/sentinel-entrypoint.sh
ENTRYPOINT ["sentinel-entrypoint.sh"]

redis-sentinel/sentinel/Dockerfile

port 26379
protected-mode no
sentinel monitor mymaster redis-master 6379 2
sentinel down-after-milliseconds mymaster 5000
sentinel parallel-syncs mymaster 1
sentinel failover-timeout mymaster 5000

redis-sentinel/sentinel/sentinel.conf

#!/bin/sh

sed -i "s/$SENTINEL_QUORUM/$SENTINEL_QUORUM/g" /etc/redis/sentinel.conf
sed -i "s/$SENTINEL_DOWN_AFTER/$SENTINEL_DOWN_AFTER/g" /etc/redis/sentinel.conf
sed -i "s/$SENTINEL_FAILOVER/$SENTINEL_FAILOVER/g" /etc/redis/sentinel.conf

exec docker-entrypoint.sh redis-server /etc/redis/sentinel.conf --sentinel

sentinel-entrypoint.sh

 

[root@linux-node4 redis-sentinel]# cd redis-sentinel/                   # 进入项目根路径
[root@linux-node4 redis-sentinel]# docker-compose up --force-recreate   # 使用docker-compose启动项目
[root@linux-node4 redis-sentinel]# docker rm -f $(docker ps -a | grep redis | awk \'{print $1}\')    # 删除所有redis相关的docker容器

　　3、集群图解 & 测试

[root@linux-node4 redis-sentinel]# redis-cli -h 127.0.0.1 -p 26379
[root@linux-node4 redis-sentinel]# redis-cli -h 127.0.0.1 -p 26380
127.0.0.1:26379> info
# Server
redis_version:5.0.7
redis_mode:sentinel
os:Linux 3.10.0-957.1.3.el7.x86_64 x86_64
tcp_port:26379
executable:/data/redis-server
config_file:/etc/redis/sentinel.conf

# Clients
connected_clients:2
client_recent_max_input_buffer:2
client_recent_max_output_buffer:0
blocked_clients:0

# Sentinel
sentinel_masters:1
sentinel_tilt:0
sentinel_running_scripts:0
sentinel_scripts_queue_length:0
sentinel_simulate_failure_flags:0
master0:name=mymaster,status=ok,address=172.17.0.2:6379,slaves=2,sentinels=2
127.0.0.1:26379> 

redis-cli -h 127.0.0.1 -p 26379 连接sentinel查看集群信息

# master上可以写入和读取，但是slave只能读取不能写入
\'\'\'打开一个新终端在redis-master写入数据  \'\'\'
[root@linux-node4 redis-sentinel]# redis-cli -h 127.0.0.1 -p 6379  
127.0.0.1:6379> set test01 master6379
OK
127.0.0.1:6379> 

\'\'\'打开第二个新终端在redis-slave可以查看master中写入的值但是salve自己不能写数据  \'\'\'
[root@linux-node4 ~]# redis-cli -h 127.0.0.1 -p 6380 
127.0.0.1:6380> get test01                # slave可以查看到master写入的数据
"master6379"
127.0.0.1:6380> set test02 redis6380      # salve自己无法写入数据
(error) READONLY You can\'t write against a read only replica.

redis-master上可以写入和读取，但是slave只能读取不能写入

[root@linux-node4 redis-sentinel]# docker stop  redis-sentinel_master_1   # 停止redis-master模拟故障
redis-sentinel_master_1
[root@linux-node4 redis-sentinel]# docker ps | grep redis                 # 确定master已经停止
88d270dad925        redis-sentinel_sentinel2  redis-sentinel_sentinel2_1
307c9c7907e0        redis-sentinel_sentinel1  redis-sentinel_sentinel1_1
2ed5dbfff01d        redis                     redis-sentinel_slave1_1
ca3b568d0b19        redis                     redis-sentinel_slave2_1

[root@linux-node4 redis-sentinel]# redis-cli -p 26379                     # 连接sentinel，发现已经选举出新的master
127.0.0.1:26379> sentinel masters
1)  1) "name"
    2) "mymaster"
    3) "ip"
    4) "172.17.0.4"
    5) "port"
    6) "6379"
    7) "runid"
    8) "af1aa34a2a013c4b776456732ee5424c5590829c"
[root@linux-node4 redis-sentinel]# docker inspect redis-sentinel_slave2_1  # 我这里查看sentinel_slave2_1的ip为172.17.0.4
[root@linux-node4 redis-sentinel]# redis-cli -h 127.0.0.1 -p 6381
127.0.0.1:6381> info                  # 查看角色
127.0.0.1:6381> set name zhangsan     # 发现主库可以进行写入啦
OK
127.0.0.1:6381> 

停止redis-master模拟故障切换

#!/usr/bin/env python
import redis
from redis.sentinel import Sentinel

# 连接哨兵服务器(主机名也可以用域名)
sentinel = Sentinel([(\'192.168.56.14\', 26379),  # 连接的是哨兵的
                     (\'192.168.56.14\', 26380),
                     ],
                    socket_timeout=2,
                    )

# 获取主服务器地址
master = sentinel.discover_master(\'mymaster\')

# 获取主服务器进行写入(密码应为redis密码)，源码中连接的是docker内部地址网络不通
master = sentinel.master_for(\'mymaster\', socket_timeout=0.5, password=\'123456\', db=15)
w_ret = master.set(\'foo\', \'bar\')
# 输出：True


# # 获取从服务器进行读取（默认是round-roubin）
slave = sentinel.slave_for(\'mymaster\', socket_timeout=0.5, password=\'redis_auth_pass\', db=15)
r_ret = slave.get(\'foo\')
print(r_ret)
# # 输出：bar

使用redis连接sentinel测试redis集群写入