##### 注：需要Redis3.2+

`C:\shixun\Redis-x64-5.0.14.1`

#### 操作步骤：

#### 1， 找到压缩包解压位置，两个配置文件，修改下配置密码：
```shell
 requirepass 123456
```	

![image.png](https://data.golovin.cn/img/dc0b75dce28e7594203ffd978ce242b7.image.png?imagevanblog)

#### 2，安装redis服务（如果已安装则先卸载）

> A. 安装指令：

```shell
 redis-server.exe --service-install redis.windows.conf
```	


![image.png](https://data.golovin.cn/img/a19ac492c0cfc5831afb8e5a3d398341.image.png?imagevanblog)

> B. 卸载指令：

```shell
 redis-server.exe --service-uninstall
```	



![image.png](https://data.golovin.cn/img/5f41cf77c572ff20bdeeada23345b18f.image.png?imagevanblog)

> C. 确保已卸载，可以查询一下：

```shell
 sc query redis
```	

>> a. 若存在Redis则如下：

![image.png](https://data.golovin.cn/img/a46fe8b05951d035bb8269860e232d28.image.png?imagevanblog)


>> b. 如果服务已卸载，这个命令将返回：失败 1060: 指定的服务未安装

![image.png](https://data.golovin.cn/img/f3f28f302d6870cdc97521c3dd40638c.image.png?imagevanblog)

		
#### 3， 启动（停止）服务，并检查密码配置是否生效：

```shell
 redis-server.exe --service-start/stop
```	

![image.png](https://data.golovin.cn/img/30ad4e8e9b151ad2058c9bc373014fae.image.png?imagevanblog)

#### 4，检查下不带密码获取value是否报错：

```shell
 redis-cli.exe
 get key
```	
	
![image.png](https://data.golovin.cn/img/c54226caf1c8cb92c3c110fbf56d1ead.image.png?imagevanblog)
 
#### 5， ok了就启动带密码：

```shell
 redis-cli.exe -a 123456
```	

> A. 这时候会有Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
>		
> B. 能够以更安全的登陆方式，先进入控制台，然后输入认证密码：

```shell
 redis-cli
 Auth 123456
```
		
![image.png](https://data.golovin.cn/img/7f95e1e9ff08ef4d72b0b8a950701a38.image.png?imagevanblog)

![image.png](https://data.golovin.cn/img/9213eb980fe19c585296f2a4e0a0438e.image.png?imagevanblog)

		
#### 6， 给每个节点分配单独的对应配置，在redis安装目录下创建对应的node700x文件夹，把conf文件放里面。

![image.png](https://data.golovin.cn/img/9068d59469a88494bd912037616c70fe.image.png?imagevanblog)

配置文件丢里面，统一命名，或者名称一样保持不同做区分也行（但是后续命令指定时需要保持相同）

![image.png](https://data.golovin.cn/img/46c9eae19e6e7a120052ecd4791289f4.image.png?imagevanblog)

![image.png](https://data.golovin.cn/img/d540370b338d1ef85ebda79df6403aac.image.png?imagevanblog)

```shell
# 配置内容举个例子：
 bind 127.0.0.1
 port 7002
 cluster-enabled yes
 cluster-config-file nodes-7002.conf
 cluster-node-timeout 5000
 appendonly yes
 appendfilename "appendonly-7002.aof"
 dbfilename "dump-7002.rdb"
 logfile "7002.log"
 dir C:\shixun\Redis-x64-5.0.14.1\data\node7002
```	

![image.png](https://data.golovin.cn/img/5dca10ba9e2ce7993029fbef4f42aef4.image.png?imagevanblog)

> a. 这个dir 配置项用于指定保存数据库文件的目录。您可以将其设置为绝对路径或相对路径：

![image.png](https://data.golovin.cn/img/4959d27741acfea1ff9bb7689fcd18e8.image.png?imagevanblog)

> b. 对应的data目录要存在

![image.png](https://data.golovin.cn/img/dcb03866bd831857f97ee838d612df00.image.png?imagevanblog)

	
#### 7， 每一个node都配置好后，就可以启动集群服务了：

```shell
# 配置内容举个例子：
 redis-server.exe .\cluster-node-7001\redis.conf
 redis-server.exe .\cluster-node-7002\redis.conf
 redis-server.exe .\cluster-node-7003\redis.conf
 redis-server.exe .\cluster-node-7004\redis.conf
 redis-server.exe .\cluster-node-7005\redis.conf
 redis-server.exe .\cluster-node-7006\redis.conf
```
注： 如果你是之前所说的非统一命名的配置文件，则需要将名称相对应

```shell
# 配置内容举个例子：
 redis-server.exe .\cluster-node-7001\redis-7001.conf
 redis-server.exe .\cluster-node-7002\redis-7002.conf
 redis-server.exe .\cluster-node-7003\redis-7003.conf
 redis-server.exe .\cluster-node-7004\redis-7004.conf
 redis-server.exe .\cluster-node-7005\redis-7005.conf
 redis-server.exe .\cluster-node-7006\redis-7006.conf
```
	
#### 8， 启动节点成功后，就可以创建集群：

```shell
# 配置内容举个例子：
 redis-cli.exe --cluster create 127.0.0.1:7001 127.0.0.1:7002 127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005 127.0.0.1:7006 --cluster-replicas 1
```

	
> a. 创建时会有提示，确认即可：yes

![image.png](https://data.golovin.cn/img/eec5120fa07ed37b34d3e66389700bd3.image.png?imagevanblog)

> b. 查看各个node的打印信息，耐心等待全部ok

![image.png](https://data.golovin.cn/img/5cc1542d1cd28bca726173ee1c6270d7.image.png?imagevanblog)

> c. 上图表示的含义就是：Redis 集群已经成功启动并运行
		
 三个主节点（M）分别分配了槽位范围，每个节点负责处理一部分槽位：
		 - 127.0.0.1:7001 负责槽位 0 到 5460
		 - 127.0.0.1:7002 负责槽位 5461 到 10922
		 - 127.0.0.1:7003 负责槽位 10923 到 16383
		
 三个从节点（S）分别复制一个主节点，形成主从复制关系：
		 - 127.0.0.1:7004 复制 127.0.0.1:7001
		 - 127.0.0.1:7005 复制 127.0.0.1:7002
		 - 127.0.0.1:7006 复制 127.0.0.1:7003

> d. 输出信息中的 `[OK] All nodes agree about slots configuration.` 表示所有节点对槽位配置达成一致。
>		
> e. 输出信息中的 `[OK] All 16384 slots covered.` 表示 16384 个槽位都已分配，集群槽位配置完整。所以，根据这些信息，我们可以得出结论：Redis 集群已成功启动并运行。
	
#### 9， 启动完毕后，可以进入集群：

```shell
 redis-cli.exe -c -p 7001
```
	
#### 10， 查看集群的状态：

```shell
 CLUSTER INFO
```

![image.png](https://data.golovin.cn/img/d7eee34b47030d41bbb8f9d98539eb22.image.png?imagevanblog)


#### 11， 查看集群节点信息：

```shell
 CLUSTER NODES
```

![image.png](https://data.golovin.cn/img/8c6338f80676936795b9e63a85637343.image.png?imagevanblog)

当然也会有失败的情况：
1. 部分节点未加入集群时，可以手动添加：CLUSTER MEET 127.0.0.1 7006
2. 如果想重启集群，就需要逐一关闭节点：redis-cli -h 127.0.0.1 -p 7001 -a 123456 shutdown
 
 1). 然后等待集群恢复，启动所有节点后集群可能需要一段时间来自动恢复，这个过程，集群可能会进行节点之间的数据同步、哈希槽位的重新分配
 
 2). 最后可以重启完毕后检查集群状态：


```shell
 redis-cli -h 127.0.0.1 -p 7001 -a 123456 cluster info
```

3. 日志中出现报错信息：

```shell
 [9448] 06 May 14:15:28.656 # fork operation failed
 [9448] 06 May 14:15:28.656 # Background AOF rewrite terminated by signal 1
 [9448] 06 May 14:15:28.769 * Background append only file rewriting started by pid 20232
 [20232] 06 May 14:15:28.817 #
 
 *** FATAL CONFIG FILE ERROR ***
 [20232] 06 May 14:15:28.817 # Reading the configuration file, at line 0
 
 [20232] 06 May 14:15:28.817 # >>> '(null)'

 [20232] 06 May 14:15:28.817 # replicaof directive not allowed in cluster mode

 [9448] 06 May 14:15:28.881 # fork operation failed
 [9448] 06 May 14:15:28.881 # Background AOF rewrite terminated by signal 1
```
		


> a. 错误日志显示的问题可能与操作系统资源限制有关
>
> b. 解决办法：以管理员身份运行 Redis：确保以管理员权限运行 Redis 进程，以便能够访问必要的系统资源。检查操作系统限制：确保操作系统允许 Redis 使用足够的文件描述符和进程。这些限制可能因操作系统和系统配置而异。检查 AOF 文件和 RDB 文件的权限和路径：确保指定的 AOF 文件（appendonly-7006.aof）和 RDB 文件（dump-7006.rdb）的路径正确，Redis 进程具有访问这些文件的权限。
>	
> c. 其实`appendonly-7006.aof` 和 `dump-7006.rdb` 这两个文件是 Redis 服务器在运行时自动生成的。它们分别用于 AOF（Append Only File）持久化和 RDB（Redis DataBase）持久化。
> 
> d. AOF 持久化：当 Redis 配置为使用 AOF 持久化时，它会将所有的写操作（例如 SET、HSET 等）追加到 AOF 文件中。当 Redis 服务器重启时，它会从 AOF 文件中读取操作并重放它们以重建数据库状态。AOF 文件名由配置文件中的 `appendfilename` 指令指定。
> 
> e. RDB 持久化：RDB 持久化是 Redis 将整个数据库的快照保存到磁盘的过程。这是通过将数据库保存到一个名为 RDB 文件的二进制文件中来完成的。RDB 文件名由配置文件中的 `dbfilename` 指令指定。
> 
> f. 当 Redis 服务器启动并开始接收命令时，如果启用了 AOF 或 RDB 持久化，它会在指定的目录中创建这些文件（由 `dir` 指令设置）。如果这些文件不存在，Redis 会自动创建它们。如果这些文件已经存在，Redis 会在启动时加载它们，并在运行过程中不断更新这些文件以保持数据的持久化。

Windows部署Redis (本地-集群)

# redissyncer简介

RedisSyncer是京东云自研的redis多任务同步中间件工具集，应用于redis单实例及集群同步。该工具集包括：

redis 同步服务引擎 redissyncer-server
redissycner 客户端 redissyncer-cli
redis 数据校验工具 redissycner-compare
基于docker-compse的一体化部署方案 redissyncer
目前在github开源：

```url
https://github.com/TraceNature/redissyncer-server
```

## 1. 缓存同步

**缓存同步的定义及必要性**

- 双向同步是指在两个实例都有存量数据和写流量的情况下进行两实例同步，最终达到两实例数据动态一致的过程
- 缓存数据全局可读，防止缓存击穿
- 保证缓存命中率，为数据库减压
- 当单一数据中心发生故障时，保证数据在另一中心完全可见

## 2. 双向同步

**双向同步的操作难度与冷启动问题**

- 原生redis同步无法区分缓存数据来源
- 由于redis本身没有实例标识(类似mysql的GTID),在双向同步时形成数据回环
- redis环状缓冲区覆盖后，数据混淆且难于清理




**基于数据冲销的双向同步方案:**
利用数据冲销的方式破除数据写入环。该方案的必要条件是，同步的实例或集群写入的key无冲突，即在数据中心A写入的key，不会同一时间在B中心写入相异值。

假设我们有两个redis实例redis1和redis2，再分别定义两个冲销池set1和set2，记录key及同步次数。

1. 启动redis1->redis2的全量同步任务
2. 启动redis1->redis2增量任务 2-1。增量任务先在set1做冲销(set1中存在的数据删除并丢弃同步) 2-2. 未被冲销数据同步到redis2
3. 启动redis2->redis1的全量任务，此全量同步数据一定会作为增量形成回环，所以要先写入set1再写入redis1，以便数据作为增量回环同步到redis2时利用set1冲销 3-1，写入set1 3-2，写入redis1
4. 启动redis2->redis1增量任务，增量任务先在set2做冲销(set2中存在的数据删除并丢弃同步)，增量任务先写入set1在写入redis1避免循环复制 4-1。通过set2冲销数据 4-2，数据写入set1 4-3，数据写入redis1
5. 改变redis1->redis2增量任务行为，增量任务先在set1做冲销(set1中存在的数据删除并丢弃同步)，未冲销数据先写入set2再同步到redis2 5-1 写入set2 5-2 写入redis2
 

 <img src="https://data.golovin.cn/img/5c1a37871ee69abdecdc7e70fe831706.image.png?imagevanblog" width="90%">

 
**为什么增加第五步改变redis1->redis2增量任务行为呢？**

因为在第四步完成时set2中并没有从redis1->redis2的增量数据，这会造成从redis1->redis2的增量数据会转换成redis2->redis1增量数据且在本地无法被冲销，只有数据进入set1且被写入redis1后再次作为增量数据向redis2同步时才会被冲销，增加了网络开销同时redis1也增加了一次写入负载。

**数据冲销方式及其缺陷**

- 数据冲销方式需要在每次发送数据前对数据进行缓冲，正常情况下缓冲内存占用不大。但当网络阻塞或由于网络不畅无法冲销数据时，会造成缓冲区暴增导致OOM
- 数据冲销方式带来的冷启动问题
 - 当任务异常中断且redis offset被覆盖的情况下，因为数据矫正依据缺失，需要重建缓存
 - 若采用数据持久化的方式先持久化后发送的方式，那么在冲销过程中会大大降低同步效率

## 3. 数据双写

数据双写，看似美好其实坑多多。业务双写是最符合人类直觉的双向方案，同一份数据写入两个数据中心以保障数据冗余。但是在实际操作中会遇到数据写入顺序问题。

**双写方案中的数据顺序问题**


 <img src="https://data.golovin.cn/img/e567f4b0c9bae6a7880af95b58bfa779.image.png?imagevanblog" width="90%">


- 并发环境中同时写入同一个key的情况下，并不能保障key写入redis的顺序。造成key的结果不一致。


 <img src="https://data.golovin.cn/img/bec1dce1a56e360153d62b566bfb48aa.image.png?imagevanblog" width="90%">


- 通过统一队列解决顺序问题
- 网络中断导致数据缺失
- 强一致性会导致单机房不可用的情况下写操作全局不可用，并需要在数据在某一次提交不完全成功的情况下提供回滚机制、及数据补偿机制
- 队列带来写效率损失，redis失去作为缓存层的意义

## 4. 双读方案


 <img src="https://data.golovin.cn/img/3e30e94de210a76288669d3695b55af5.image.png?imagevanblog" width="90%">


- 每个数据中心建立redis 读写实例与只读实例
- 读写数据中的落地数据通过redissyncer同步到对端只读实例
- 应用读数据时先读取只读实例若有数据返回则返回；若无数据返回则读取读写实例
- 双读方案的限制条件
 - key的生成在全局具有唯一性既两个中心不出现重复的key
 - 避免incr 、 lpush 等非幂等操作
 - 由于网络抖动可能造成数据流中断，尽管redissyncer以及对非幂等命令做了处理，但是极端情况仍然可能造成数据不准确影响业务


**双读方案实践模拟**

**环境列表**


| 主机名 | IP地址 | 部署软件或工具 |
|----------|------------|---------------|
| az_a1 | 10.0.0.110 | redis5.0 |
| az_a1 | 10.0.0.110 | redissyncer |
| az_a2 | 10.0.0.111 | redis5.0 |
| az_b1 | 10.0.0.112 | redis5.0 |
| az_b1 | 10.0.0.112 | redissyncer |
| az_b2 | 10.0.0.113 | redis5.0 |

- az_a1 代表 a 中心的 redis RW 实例；az_a2 代表 a 中心 redis RO 实例；az_b1 代表 b 中心 redis RW 实例；az_b2 代表 b 中心 redis RO 实例
- 分别在 az_a1、az_b1上部署 redissyncer 用于同步到对端数据中心
- 通过 redisdual 模拟双读客户端

**实施细则**

部署 redis 详见 redis 部署文档，这里不累述

部署redissyncer（docker方式）; az_a1、az_b1 上执行

clone redissyncer 项目

部署 redissyncer-cli 用于与服务器通讯

- 下载客户端程序


 ```shell
 wget https://github.com/TraceNature/redissyncer-cli/releases/download/v0. 1.0/redissyncer-cli-0.1.0-linux-amd64.tar.gz
 ```


 ```shell
 tar zxvf redissyncer-cli-0.1.0-linux-amd64.tar.gz 
 ```
az_a1 配置同步任务同步到 az_b2

- 编辑任务文件 synctask/a1_to_b2.json


```json
{
 "sourcePassword": "redistest0102",
 "sourceRedisAddress": "10.0.0.112:16375",
 "targetRedisAddress": "10.0.0.111:16375",
 "targetPassword": "redistest0102",
 "taskName": "b1_to_a2",
 "targetRedisVersion": 5.0,
 "autostart": true,
 "afresh": true,
 "batchSize": 100
}
```
通过redisdual 模拟redis 双读

config.yaml 文件参数详解

主要代码分析


```go
func dual(rw *redis.Client, ro *redis.Client, key string) {
 roResult, err := ro.Get(key).Result()

 if err == nil && roResult != "" {
 global.RSPLog.Sugar().Infof("Get key %s from redisro result is:%s ", key, roResult)
 return
 }

 rwResult, err := rw.Get(key).Result()
 if err != nil || rwResult == "" {
 global.RSPLog.Sugar().Infof("key %s no result return!", key)
 return
 }

 global.RSPLog.Sugar().Infof("Get key %s from redisrw result is: %s ", key, rwResult)

}
```

redisdual/cmd/start.go；func startServer() 函数。启动服务，定时执行RW实例写入。并执行双读操作


```go
// -d 后台启动
if global.RSPViper.GetBool("daemon") {
 cmd,
 err: =background() if err != nil {
 panic(err)
 }

 //根据返回值区分父进程子进程
 if cmd != nil { //父进程
 fmt.Println("PPID: ", os.Getpid(), "; PID:", cmd.Process.Pid, "; Operating parameters: ", os.Args) return //父进程退出
 } else { //子进程
 fmt.Println("PID: ", os.Getpid(), "; Operating parameters: ", os.Args)
 }
}

global.RSPLog = core.Zap() global.RSPLog.Info("server start ... ")

pidMap: =make(map[string] int)
// 记录pid
pid: =syscall.Getpid() pidMap["pid"] = pid

pidYaml, _: = yaml.Marshal(pidMap) 
dir, err: = filepath.Abs(filepath.Dir(os.Args[0])) 
if err != nil {
 panic(err)
}

if err: =ioutil.WriteFile(dir + "/pid", pidYaml, 0664);
err != nil {
 global.RSPLog.Sugar().Error(err) panic(err)
}
global.RSPLog.Sugar().Infof("Actual pid is %d", pid)

//redis 读写实例
redisRW: =GetRedisRW()

//redis 只读实例
redisRO: =GetRedisRO()

//清理RW
redisRW.FlushAll()

global.RSPLog.Sugar().Info("execinterval:", global.RSPViper.GetInt("execinterval")) 
loopstep: =global.RSPViper.GetInt("loopstep") i: =0
for {
 if i > loopstep {
 i = 0
 }
 key: =global.RSPViper.GetString("localkeyprefix") + "_key" + strconv.Itoa(i)
 redisRW.Set(key, key + "_" + strconv.FormatInt(time.Now().UnixNano(), 10), 3600 * time.Second) 
 dual(redisRW, redisRO, global.RSPViper.GetString("localkeyprefix") + "_key" + strconv.Itoa(i)) 
 dual(redisRW, redisRO, global.RSPViper.GetString("remotekeyprefix") + "_key" + strconv.Itoa(i)) 
 i++
 time.Sleep(time.Duration(global.RSPViper.GetInt("execinterval")) * time.Millisecond)
}
```

- 启动redisdual 并观察日志

 `redisdual start`

# 小结

redis的双向同步方案的机制大致就是以上三种，具体生产中采用哪种方式要根据业务特性进行权衡。从数据安全和维护成本方面考虑，双读方案从运维成本来讲是最少的，且在故障发生时不会引起数据混淆。

注：需要Redis3.2+

操作步骤：

1， 找到压缩包解压位置，两个配置文件，修改下配置密码：

2，安装redis服务（如果已安装则先卸载）

redissyncer简介

1. 缓存同步

2. 双向同步

1，找到压缩包解压位置，两个配置文件，修改下配置密码：