springboot+redis+angular+zookeeper+kafka等实战

很遗憾，看了很多文章都没有我想要很多实际中能切合。脱离了环境的说明我不认为是有效的。

基础环境要有，这里使用docker构建基础环境。没有基础就不要看这篇文章了，不然浪费时间，其次东西完全是个人研究用，不保证100%对。
保证docker虚拟机已有。

1、redis集群配置：下面的一切依照官网而来。
dockerhub官网
搜索redis。选择适合你虚拟机的版本。
这是我的版本。并确保环境干净。

Connecting to 192.168.253.129:22...
Connection established.
To escape to local shell, press 'Ctrl+Alt+]'.

Welcome to Ubuntu 16.04.6 LTS (GNU/Linux 4.15.0-112-generic x86_64)

 * Documentation:  https://help.ubuntu.com
 * Management:     https://landscape.canonical.com
 * Support:        https://ubuntu.com/advantage
root@ubuntu:~# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE

我们先来装一个redis，并尝试调试成功，再来集群化，并将过程dockerFile脚本化。
按照官网一步步来：

# 安装最新redis
root@ubuntu:~# docker pull redis
Using default tag: latest
latest: Pulling from library/redis
d121f8d1c412: Pull complete 
2f9874741855: Pull complete 
d92da09ebfd4: Pull complete 
bdfa64b72752: Pull complete 
e748e6f663b9: Pull complete 
eb1c8b66e2a1: Pull complete 
Digest: sha256:a05a8a1ebbef72690034a77451e6e83f4d899779190d1c00d8ab1a3a4fbbbd22
Status: Downloaded newer image for redis:latest
docker.io/library/redis:latest
# 查看已安装镜像
root@ubuntu:~# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
redis               latest              84c5f6e03bf0        39 hours ago        104MB
# 启动容器，要做端口映射，如果不了解网络原理，自己去查。
root@ubuntu:~# docker run --name myredis -p 6379:6379 -d redis redis-server
11d70622fcb1bf6985423f94c2afbd7b390609656985193997cbb2bf3a9dd02f
# 查看已启动容器
root@ubuntu:~# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                    NAMES
11d70622fcb1        redis               "docker-entrypoint.s…"   28 seconds ago      Up 27 seconds       0.0.0.0:6379->6379/tcp   myredis
# 服务其上测试安装成功，并可使用
root@ubuntu:~# docker exec -it 11d70622fcb1 /bin/bash
root@11d70622fcb1:/data# redis-cli
127.0.0.1:6379> set mykey "test ok"
OK
127.0.0.1:6379> get mykey
"test ok"
127.0.0.1:6379> 

测试本地如何连接上我们服务器上的docker:
首先redis desktop manager连接成功：

本地新建一个springboot工程:
pom.xml如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.docker</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--    这个包是必须的    -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>2.6.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

配置文件application.properties：

# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址
spring.redis.host=192.168.253.129
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制） 默认 8
spring.redis.lettuce.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
spring.redis.lettuce.pool.max-wait=-1
# 连接池中的最大空闲连接 默认 8 使用lettuce
spring.redis.lettuce.pool.max-idle=8
# 连接池中的最小空闲连接 默认 0
spring.redis.lettuce.pool.min-idle=0

测试类：

package com.docker.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class DemoController {

    @Autowired
    private StringRedisTemplate redisTemplate;

    @RequestMapping("/test")
    @ResponseBody
    public String test() {

        return redisTemplate.opsForValue().get("mykey");
    }
}

测试结果如下：

到此说明这一切是通，我们这一系列过程是对的。那么接下里就是复杂化，并编写脚本实现。
首先我要创建给redis创一个network: 这是为了保证了集群化在一个网段内。

root@ubuntu:~# docker network create redis  --subnet 172.38.0.0/16
root@ubuntu:~# docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
ba7152491897        bridge              bridge              local
6c14996eff23        host                host                local
dcce898c2df5        none                null                local
868ef963e47e        redis               bridge              local

创建6个redis的脚本：

root@ubuntu:/home/script# vim redis.sh 
root@ubuntu:/home/script# sh redis.sh 
root@ubuntu:/home/script# pwd
/home/script
root@ubuntu:/home/script# cd /mydata
root@ubuntu:/mydata# cd redis/
root@ubuntu:/mydata/redis# ls
node-1  node-2  node-3  node-4  node-5  node-6
root@ubuntu:/mydata/redis# cd node-1
root@ubuntu:/mydata/redis/node-1# ls
conf  data

脚本：

# 脚本创建6个redis
for port in $(seq 1 6);\
do \
mkdir -p /mydata/redis/node-${port}/conf
touch /mydata/redis/node-${port}/conf/redis.conf
cat <<EOF> /mydata/redis/node-${port}/conf/redis.conf
protected-mode no
port 6379
tcp-backlog 511
timeout 0
tcp-keepalive 300
daemonize no
supervised no
pidfile /var/run/redis_6379.pid
loglevel notice
logfile ""
databases 16
always-show-logo yes
save 900 1
save 300 10
save 60 10000
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
dbfilename dump.rdb
dir ./
replica-serve-stale-data yes
replica-read-only yes
repl-diskless-sync no
repl-diskless-sync-delay 5
repl-disable-tcp-nodelay no
replica-priority 100
requirepass useaverystrongpasswordfoobared666useaverystrongpassword888useaverystrongpassword999useaverystrongpassword110
lazyfree-lazy-eviction no
lazyfree-lazy-expire no
lazyfree-lazy-server-del no
replica-lazy-flush no
appendonly no
appendfilename "appendonly.aof"
appendfsync everysec
no-appendfsync-on-rewrite no
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
aof-load-truncated yes
aof-use-rdb-preamble yes
lua-time-limit 5000
slowlog-log-slower-than 10000
slowlog-max-len 128
latency-monitor-threshold 0
notify-keyspace-events ""
hash-max-ziplist-entries 512
hash-max-ziplist-value 64
list-max-ziplist-size -2
list-compress-depth 0
set-max-intset-entries 512
zset-max-ziplist-entries 128
zset-max-ziplist-value 64
hll-sparse-max-bytes 3000
stream-node-max-bytes 4096
stream-node-max-entries 100
activerehashing yes
client-output-buffer-limit normal 0 0 0
client-output-buffer-limit replica 256mb 64mb 60
client-output-buffer-limit pubsub 32mb 8mb 60
hz 10
dynamic-hz yes
aof-rewrite-incremental-fsync yes
rdb-save-incremental-fsync yes
# 集群配置
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-announce-ip 172.38.0.1${port}
cluster-announce-port 6379
EOF
done

root@ubuntu:/home/script# vim redis-start.sh

# 启动脚本
for port in $(seq 1 6); \
do \ 
docker run -d -p 637${port}:6379 -p 1637${port}:16379 --name redis-${port} \
-v /mydata/redis/node-${port}/data:/data \
-v /mydata/redis/node-${port}/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.1${port} redis:5.0.9 redis-server /etc/redis/redis.conf; \
done

然而并不是那么顺利，我们发现启动了就立马退出了。来变量控制是什么导致这个原因的。

root@ubuntu:/etc# docker run --name myredis -p 6379:6379 -p 16379:16379  -d redis redis-server /etc/redis/redis.conf;
6ae8653bab807a05bb7717b2cefa112e582d4580ce9d096c1c5e3fd40ae37a1e
root@ubuntu:/etc# docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
root@ubuntu:/etc# docker ps -a
CONTAINER ID        IMAGE               COMMAND                  CREATED              STATUS                          PORTS               NAMES
6ae8653bab80        redis               "docker-entrypoint.s…"   About a minute ago   Exited (1) About a minute ago                       myredis
root@ubuntu:/etc# docker run --name myredis -p 6379:6379 -p 16379:16379  -d redis redis-server
docker: Error response from daemon: Conflict. The container name "/myredis" is already in use by container "6ae8653bab807a05bb7717b2cefa112e582d4580ce9d096c1c5e3fd40ae37a1e". You have to remove (or rename) that container to be able to reuse that name.
See 'docker run --help'.
root@ubuntu:/etc# docker rm -f $(docker ps -aq)
6ae8653bab80
root@ubuntu:/etc# docker run --name myredis -p 6379:6379 -p 16379:16379  -d redis redis-server
a0dc6522d49ed8d93841e7ab8affad5f69c37287511d85f5a71e0d109285c1ff
root@ubuntu:/etc# docker ps 
CONTAINER ID        IMAGE               COMMAND                  CREATED              STATUS              PORTS                                              NAMES
a0dc6522d49e        redis               "docker-entrypoint.s…"   About a minute ago   Up About a minute   0.0.0.0:6379->6379/tcp, 0.0.0.0:16379->16379/tcp   myredis

通过上面我们可以发现，启动不加配置文件是可以启动的。启动加上配置文件，启动就立马停止了，所以问题应该出在/etc/redis/redis.conf配置中，

root@ubuntu:/# find -name "redis.conf"
./mydata/redis/node-2/conf/redis.conf
./mydata/redis/node-6/conf/redis.conf
./mydata/redis/node-3/conf/redis.conf
./mydata/redis/node-1/conf/redis.conf
./mydata/redis/node-4/conf/redis.conf
./mydata/redis/node-5/conf/redis.conf

可以发现，并没有这个文件。从官网下载（是指下载对应的redis打开安装好后，找到该文件放上去）
放上去后就可以看到该目录文件了。个人建议不要用最新版，不好查版本。

root@ubuntu:/# find -name "redis.conf"
./mydata/redis/node-2/conf/redis.conf
./mydata/redis/node-6/conf/redis.conf
./mydata/redis/node-3/conf/redis.conf
./mydata/redis/node-1/conf/redis.conf
./mydata/redis/node-4/conf/redis.conf
./mydata/redis/node-5/conf/redis.conf
find: ‘./run/user/1000/gvfs’: Permission denied
./etc/redis/redis.conf

我们再来试一试：结果还是失败。
检查配置文件是否设置了daemonize yes，如果是，就要改为daemonize no，因为该选项让redis成为在后台运行的守护进程，而docker容器必须要有一个前台进程才能留存。我们启动的时候又使用了-d命令。
然而也不是这个原因。

清空环境。从头再来，我们去先去下载一个tar包
再去docker pull redis:5.0.9,从而保证变量一致性。
将上面配置文件脚本改为：

protected-mode no
port 6379
tcp-backlog 511
timeout 0
tcp-keepalive 300
daemonize no
supervised no
pidfile /var/run/redis_6379.pid
loglevel notice
logfile ""
databases 16
always-show-logo yes
save 900 1
save 300 10
save 60 10000
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
dbfilename dump.rdb
dir ./
replica-serve-stale-data yes
replica-read-only yes
repl-diskless-sync no
repl-diskless-sync-delay 5
repl-disable-tcp-nodelay no
replica-priority 100
# requirepass 123456
lazyfree-lazy-eviction no
lazyfree-lazy-expire no
lazyfree-lazy-server-del no
replica-lazy-flush no
appendonly no
appendfilename "appendonly.aof"
appendfsync everysec
no-appendfsync-on-rewrite no
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
aof-load-truncated yes
aof-use-rdb-preamble yes
lua-time-limit 5000
slowlog-log-slower-than 10000
slowlog-max-len 128
latency-monitor-threshold 0
notify-keyspace-events ""
hash-max-ziplist-entries 512
hash-max-ziplist-value 64
list-max-ziplist-size -2
list-compress-depth 0
set-max-intset-entries 512
zset-max-ziplist-entries 128
zset-max-ziplist-value 64
hll-sparse-max-bytes 3000
stream-node-max-bytes 4096
stream-node-max-entries 100
activerehashing yes
client-output-buffer-limit normal 0 0 0
client-output-buffer-limit replica 256mb 64mb 60
client-output-buffer-limit pubsub 32mb 8mb 60
hz 10
dynamic-hz yes
aof-rewrite-incremental-fsync yes
rdb-save-incremental-fsync yes

主要改了：（密码不重要）

# bind 127.0.0.1
protected-mode no
# 可以不设，配置前可以设置，后面一定要设置
requirepass 123456
daemonize no

结果如下：

root@ubuntu:/mydata# docker run -p 6371:6379 -p 16371:16379 --name redis-1 -v /mydata/redis/node-1/conf/redis.conf:/etc/redis/redis.conf -d --net redis --ip 172.38.0.11 redis:5.0.9 redis-server /etc/redis/redis.conf;
64055d4b6eb8d19841da7ad09e6ba42481f21bfb26730fb6aec6725ecca3066d
root@ubuntu:/mydata# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                                              NAMES
64055d4b6eb8        redis:5.0.9         "docker-entrypoint.s…"   9 seconds ago       Up 7 seconds        0.0.0.0:6371->6379/tcp, 0.0.0.0:16371->16379/tcp   redis-1

反过去修改上面的脚本。
运行脚本的最终结果如下面：

root@ubuntu:/home/script# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                                              NAMES
15a0b18c9b9a        redis:5.0.9         "docker-entrypoint.s…"   7 seconds ago       Up 6 seconds        0.0.0.0:6376->6379/tcp, 0.0.0.0:16376->16379/tcp   redis-6
d097f6d6050c        redis:5.0.9         "docker-entrypoint.s…"   8 seconds ago       Up 7 seconds        0.0.0.0:6375->6379/tcp, 0.0.0.0:16375->16379/tcp   redis-5
acd8389e8f4f        redis:5.0.9         "docker-entrypoint.s…"   10 seconds ago      Up 8 seconds        0.0.0.0:6374->6379/tcp, 0.0.0.0:16374->16379/tcp   redis-4
976040c90afb        redis:5.0.9         "docker-entrypoint.s…"   11 seconds ago      Up 9 seconds        0.0.0.0:6373->6379/tcp, 0.0.0.0:16373->16379/tcp   redis-3
ce1e9d501b74        redis:5.0.9         "docker-entrypoint.s…"   12 seconds ago      Up 11 seconds       0.0.0.0:6372->6379/tcp, 0.0.0.0:16372->16379/tcp   redis-2
ab69091e80ac        redis:5.0.9         "docker-entrypoint.s…"   13 seconds ago      Up 12 seconds       0.0.0.0:6371->6379/tcp, 0.0.0.0:16371->16379/tcp   redis-1

重点注意：一定要保证环境的版本的一致性。控制变量的一致性

集群的配置，可以在这里配置，但是只是一次有效。所以我们还是在springboot中依赖配置文件去配置比较好。

还是上面的环境。来配置集群和哨兵模式。
前面我们学习redis的时候我们介绍过：Redis哨兵（Sentinel）和自动分区（Cluster）
集群方案 —— 包括主从复制模式、哨兵模式、Cluster模式，其中主从复制模式由于不能自动做故障转移，当节点出现故障时需要人为干预，不满足生产环境的高可用需求，所以在生产环境一般使用哨兵模式或Cluster模式。

采用自动分区（Cluster）模式：

你需要仔细阅读官网或者英文官网
官网的一句原话：要让集群正常运作至少需要三个主节点，不过在刚开始试用集群功能时， 强烈建议使用六个节点： 其中三个为主节点， 而其余三个则是各个主节点的从节点。
所以先来规划主从的设置：这是前面已经配好的节点。

192.168.253.129:6371 主 -> 192.168.253.129:6374 从
192.168.253.129:6372 主 -> 192.168.253.129:6375 从
192.168.253.129:6373 主 -> 192.168.253.129:6376 从

去一个认老大的例子，不想累述：

root@ubuntu:~# docker exec -it acd8389e8f4f /bin/bash
root@acd8389e8f4f:/data# redis-cli
127.0.0.1:6379> info replication
NOAUTH Authentication required.
127.0.0.1:6379> auth useaverystrongpasswordfoobared666useaverystrongpassword888useaverystrongpassword999useaverystrongpassword110
OK
127.0.0.1:6379> info replication
# Replication
role:master
connected_slaves:0
master_replid:a6917a80cc325dbc44e73b5e68babd1db455dd65
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0
127.0.0.1:6379> 

每个节点都是如此，就难受了。区分不开。上面的脚本有问题。没有集群化处理，集群化参数官网说明。重新写的脚本依旧在上面。
脚本添加：

cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-announce-ip 172.38.0.1${port}
cluster-announce-port 6379

为了方便重来新建清除脚本 clear-redis.sh：

for cid in $(docker ps -aq);
do
docker stop $cid
done
docker rm -f $(docker ps -aq)
rm -rf mydata/

发现需要密码验证，修改脚本注释密码或者脚本验证密码。重新执行一遍。个人建议脚本验证密码。如果不会就注释掉吧。

在执行如下语句：分析下面的语句。

root@ubuntu:/home/script# docker exec -it 17f8a1f0e182 /bin/bash
root@17f8a1f0e182:/data# redis-cli --cluster create 172.38.0.11:6379 172.38.0.12:6379 172.38.0.13:6379 172.38.0.14:6379 172.38.0.15:6379 172.38.0.16:6379 --cluster-replicas 1
# 有6个基点插槽  选项–replicas 1 表示我们希望为集群中的每个主节点创建一个从节点。如果自定义–replicas 1 172.38.0.11:6379 他后面跟的全部就是master
>>> Performing hash slots allocation on 6 nodes...
Master[0] -> Slots 0 - 5460
Master[1] -> Slots 5461 - 10922
Master[2] -> Slots 10923 - 16383
# 给了默认的推荐方式，即三主三从。你选择yes即可，当然你也自定义你想要的方式。不过一般默认推荐，实际环境有要求除外。
Adding replica 172.38.0.15:6379 to 172.38.0.11:6379
Adding replica 172.38.0.16:6379 to 172.38.0.12:6379
Adding replica 172.38.0.14:6379 to 172.38.0.13:6379
M: 67fd9000233cfaee016e1f71e2d1c4415b962eae 172.38.0.11:6379
   slots:[0-5460] (5461 slots) master
M: 9452f6832d53eafe3d9766ac3926f1064bcaba45 172.38.0.12:6379
   slots:[5461-10922] (5462 slots) master
M: 5543b59af158f22ae763896742500fe78e83ebdb 172.38.0.13:6379
   slots:[10923-16383] (5461 slots) master
S: 79e3cf433d91f1a5584271c6df395a02d726ce29 172.38.0.14:6379
   replicates 5543b59af158f22ae763896742500fe78e83ebdb
S: 2297ccf2b9aaeb99c90f50f1db8d7fc951ee91e9 172.38.0.15:6379
   replicates 67fd9000233cfaee016e1f71e2d1c4415b962eae
S: 10f0bdfef9df4501ac78e604171b67025ee3b89a 172.38.0.16:6379
   replicates 9452f6832d53eafe3d9766ac3926f1064bcaba45
Can I set the above configuration? (type 'yes' to accept): yes
>>> Nodes configuration updated
>>> Assign a different config epoch to each node
>>> Sending CLUSTER MEET messages to join the cluster
Waiting for the cluster to join
....
# 选择yes后，最后主从结果显示。
>>> Performing Cluster Check (using node 172.38.0.11:6379)
M: 67fd9000233cfaee016e1f71e2d1c4415b962eae 172.38.0.11:6379
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
M: 5543b59af158f22ae763896742500fe78e83ebdb 172.38.0.13:6379
   slots:[10923-16383] (5461 slots) master
   1 additional replica(s)
M: 9452f6832d53eafe3d9766ac3926f1064bcaba45 172.38.0.12:6379
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
S: 2297ccf2b9aaeb99c90f50f1db8d7fc951ee91e9 172.38.0.15:6379
   slots: (0 slots) slave
   replicates 67fd9000233cfaee016e1f71e2d1c4415b962eae
S: 10f0bdfef9df4501ac78e604171b67025ee3b89a 172.38.0.16:6379
   slots: (0 slots) slave
   replicates 9452f6832d53eafe3d9766ac3926f1064bcaba45
S: 79e3cf433d91f1a5584271c6df395a02d726ce29 172.38.0.14:6379
   slots: (0 slots) slave
   replicates 5543b59af158f22ae763896742500fe78e83ebdb

还是那句话，这里的配置并不是永久的配置，服务器重启，你就的在这样配置一次。所以还是要依赖springboot配置文件去配置。

测试外界连接：redis desktop manager连接成功.

注意：集群的连接需要在高级设置里面选择集群。
如果需求用集群方式链接的话，勾选集群完毕后，链接一个单点redis则相当于链接了整个redis集群，否则则认为只做单点链接。

另外如果有需要你需要添加一个新节点、添加一个从节点、删除一个节点、节点的迁移这是非常重要的研究点，官网已经给了一个完整的实例，不累述。

调试发现不能连接：😭😭

服务器上测试：

root@ubuntu:~# docker exec -it 51aa2d97848e /bin/bash
root@51aa2d97848e:/data# redis-cli
127.0.0.1:6379> set mykey "test ok"
(error) MOVED 14687 172.38.0.13:6379
127.0.0.1:6379> exit
# 解决方式
root@51aa2d97848e:/data# redis-cli -c
127.0.0.1:6379> set mykey "test ok"
-> Redirected to slot [14687] located at 172.38.0.13:6379
OK
172.38.0.13:6379> get mykey
"test ok"
172.38.0.13:6379> 

没啥用啊！我要的是实际生成环境能连接上并且能用。该如何配置呢。

查看docker网络配置:

root@ubuntu:~# docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
ba7152491897        bridge              bridge              local
6c14996eff23        host                host                local
dcce898c2df5        none                null                local
868ef963e47e        redis               bridge              local
root@ubuntu:~# docker network inspect 868ef963e47e
[
    {
        "Name": "redis",
        "Id": "868ef963e47e0b085f1cdf00c70344d3cfbb227d0995812ae688b107b8aeaeb9",
        "Created": "2020-08-09T01:16:13.879953848-07:00",
        "Scope": "local",
        # 使用的桥连接模式
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": {},
            "Config": [
                {
                    "Subnet": "172.38.0.0/16",
                    "Gateway": "172.38.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Ingress": false,
        "ConfigFrom": {
            "Network": ""
        },
        "ConfigOnly": false,
        "Containers": {
            "17f8a1f0e182220c845d354a75a5edfa947a29c4ca3cf4b22ff083b3929e1309": {
                "Name": "redis-4",
                "EndpointID": "fb49fd87b68f8f351889f20381ddce1e6888dfbc4735bdfdede8cc1e5e095e3f",
                "MacAddress": "02:42:ac:26:00:0e",
                "IPv4Address": "172.38.0.14/16",
                "IPv6Address": ""
            },
            "2e1b478691d9b95ca2904a49bfe131fa76c71e8a1c6867eac5ea35889d29e611": {
                "Name": "redis-6",
                "EndpointID": "21db2ce82ca82e0d8b60fc38bf45938c057207f8b51c67fca9c5e55f6eabb833",
                "MacAddress": "02:42:ac:26:00:10",
                "IPv4Address": "172.38.0.16/16",
                "IPv6Address": ""
            },
            "4d647a2beb707bcd7162cdbd76e0c9ad6105d17bc676e02f48458d40fd9458ed": {
                "Name": "redis-5",
                "EndpointID": "64bfc2186c2372c3ff77355b1ab9b89ff9c611bb159aefca5e8c7e6c44b761b8",
                "MacAddress": "02:42:ac:26:00:0f",
                "IPv4Address": "172.38.0.15/16",
                "IPv6Address": ""
            },
            "51aa2d97848ea8871464828f9b5599d437e2afca2d49b62984df9028945a29b7": {
                "Name": "redis-1",
                "EndpointID": "f6dd99c820d97f72d2a8ad9e64701c416e755dde409348962b530c8835b02d41",
                "MacAddress": "02:42:ac:26:00:0b",
                "IPv4Address": "172.38.0.11/16",
                "IPv6Address": ""
            },
            "8ee555e7c91cc0f80901b0f2cc2eab9ea259255720c6a509c88ba16903271ee7": {
                "Name": "redis-3",
                "EndpointID": "bbe352a3bc1d3e04008d773aafe2ad5ec134345f505a761592255f9cdef26c88",
                "MacAddress": "02:42:ac:26:00:0d",
                "IPv4Address": "172.38.0.13/16",
                "IPv6Address": ""
            },
            "eaa0722997970300a171795c1bc51c6416fce962aeaed973abee884331027809": {
                "Name": "redis-2",
                "EndpointID": "c757e8b9b4e80d9d82a65f15681309335e3056906c51597058461ac5278741cd",
                "MacAddress": "02:42:ac:26:00:0c",
                "IPv4Address": "172.38.0.12/16",
                "IPv6Address": ""
            }
        },
        "Options": {},
        "Labels": {}
    }
]

查看网络：

root@ubuntu:~# ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host 
       valid_lft forever preferred_lft forever
2: ens33: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
    link/ether 00:50:56:29:69:8a brd ff:ff:ff:ff:ff:ff
    inet 192.168.253.129/24 brd 192.168.253.255 scope global dynamic ens33
       valid_lft 1273sec preferred_lft 1273sec
    inet6 fe80::d86d:a7f8:2c6f:ab9c/64 scope link 
       valid_lft forever preferred_lft forever
# 没毛病172.38.0.1/16 有了呀。感叹网络原理学的太差了😭
3: br-868ef963e47e: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:9f:2c:a4:a2 brd ff:ff:ff:ff:ff:ff
    inet 172.38.0.1/16 brd 172.38.255.255 scope global br-868ef963e47e
       valid_lft forever preferred_lft forever
    inet6 fe80::42:9fff:fe2c:a4a2/64 scope link 
       valid_lft forever preferred_lft forever
4: docker0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN group default 
    link/ether 02:42:a5:f1:31:77 brd ff:ff:ff:ff:ff:ff
    inet 172.17.0.1/16 brd 172.17.255.255 scope global docker0
       valid_lft forever preferred_lft forever
    inet6 fe80::42:a5ff:fef1:3177/64 scope link 

也没啥毛病啊！但是就是ping不通。

继续排查，尝试windows能操作或路由有问题？
打开window上的cmd。注意集群-c是一定要的。下面需要注意我ip了以下。
下面的ip+端口如下划线部分。

C:\Users\zy962>redis-cli -h 192.168.253.139:6371 -p 6371 -c
Could not connect to Redis at 192.168.253.139:6371:6371: 不知道这样的主机。
not connected> c^C
C:\Users\zy962>redis-cli -h 192.168.253.139 -p 6371 -c
192.168.253.139:6371> set key11 123
OK
192.168.253.139:6371> get key11
"123"
192.168.253.139:6371>

如果有密码

redis-cli -h 192.168.253.139:6371 -p 6371 -c -a 123456

运行结果：这说明windows上是可操作的。注意这里操作没有重定向，可能导致问题。后面如果有遇到再说。

添加路由关系：

结果：注意要用管理员权限启动cmd

重新启动原先的测试程序：测试成功。

到此cluster集群测试完毕。redis框架已搭好。
在这里一点哨兵模式：以下说关于哨兵的没有实践。正确性自己保重。
服务器的配置：
1、同上是面的目录（可以随便建目录）/etc/redis/sentinel.conf官网上说了，最简单的配置：

#  第一行配置指示 Sentinel 去监视一个名为 mymaster 的主服务器， 
# 这个主服务器的 IP 地址为 127.0.0.1 ， 端口号为 6379 ，这个2的意思 
# 将这个主服务器判断为失效至少需要 2 个 Sentinel 同意
sentinel monitor mymaster 127.0.0.1 6379 2
# down-after-milliseconds指定了 Sentinel 认为服务器已经断线所需的毫秒数。
sentinel down-after-milliseconds mymaster 60000
sentinel failover-timeout mymaster 180000
# parallel-syncs执行故障转移时， 最多可以有多少个从服务器同时对新的主服务器进行同步， 这个数字越小， 完成故障转移所需的时间就越长。
sentinel parallel-syncs mymaster 1

这个配置文件需要挂载几份取决于你计划要几个哨兵。

个人建议：下面部分最好加进去。

# bind 127.0.0.1
protected-mode no
# 可以不设，配置前可以设置，后面一定要设置
requirepass 123456
daemonize no

关于主从：可以只在从服务器下加上这个。 上面可以指定端口，也可以默认。当进入去认老大也是可以的。

# 指定主服务器，注意：有关slaveof的配置只是配置从服务器，主服务器不需要配置
slaveof 127.0.0.1 6379

还可以设置：

# 注意他和requirepass区别
sentinel auth-pass mymaster 123456

启动三个容器：举一个例子。

docker run -d -p 6371:6379 --name redis-1 \
-v /mydata/redis/node-1/data:/data \
-d --net redis --ip 172.38.0.11 redis:5.0.9 redis-server

解释：
1、启动就用默认配置redis.conf
2、端口不需要+10000

注意：记得主从设置
启动哨兵：

docker run -p 6371:6371 --restart=always --name sentinel-6371 \
-v/home/docker/redis/sentinel-6371.conf:/etc/redis/sentinel.conf \
-v /home/docker/redis/sentinel-6371-data:/data -d redis redis-sentinel /etc/redis/sentinel.conf

window端配置只有配置文件上的一点小差距：
将上面cluster的部分为下面的

#redis 哨兵监听的Redis Server的名称
spring.redis.sentinel.master=mymaster
# comma-separated list of host:port pairs  哨兵的配置列表
spring.redis.sentinel.nodes=127.0.0.1:26379,127.0.0.1:36379,127.0.0.1:46379

zookeeper + kafka的搭建：kafka依赖于zookeeper
首先你要有基本的概念：拿日志举例子

常见问题：
1、如何区分服务，服务名。给每个微服务取名比如filter、manage
2、缺点：当发生JVM内存泄漏、内存溢出等情况无法定位到具体服务器

首先，如果条件允许，建议3个vm模拟较好。采用先搭建好一个，其余克隆修改配置文件即可。（由于电脑垃圾，这里我只说明过程不演示，后面我会用docker模拟）
vm过程：
1、下载zookeeper的tar包，解压tar -zxvf zookeeper-3.4.14.tar.gz，重命名mv zookeeper-3.4.14 zookeeper。
2、进入解压后的目录，修改配置文件名mv zoo_sample.cfg zoo.cfg
3、配置文件后添加：vim zoo.cfg

server.0=192.168.253.174:2888:3888
server.1=192.168.253.175:2888:3888
server.2=192.168.253.176:2888:3888

4、创建服务器标识：
创建文件vim /usr/local/zoo/data/myid 该文件存你的id即可

0

5、配置环境变量：vi /etc/profile

export ZOOKEEPER_HOME=/usr/local/zoo
export PATH=$PATH:$ZOOKEEPER_HOME/bin

6、下载kafka的tar包,并解压。去版本号命名。先检查是否安装了jdk，没有则安装。
7、修改配置文件：vim /kafka/config/server.properties

dataDir=/usr/local/zoo/data
# 对应的ip:端口
listeners=PLAINTEXT://192.168.253.131:9092
# zk集群连接
zookeeper.connect=192.168.253.174:2888,192.168.253.175:2888,192.168.253.176:2888
# 对应你zk的myid文件的值
broker.id=0

8、系统环境变量配置kafka的路径：vim /etc/profile
添加：如果是其他写法，参考别人怎么写的即可。

export KAFKA_HOME=/usr/local/kafka
export PATH=$PATH:$KAFKA_HOME/bin

修改后，重启动：source /etc/profile（这个命令待确认）

9、zk启动等脚本：去到对应的bin下，zk集群是要先启动的。不要着急启动，先克隆另外两个vm配置好后，在统一启动zk，在启动kafka。参考第11点。

# 1、启动zk  
sh zkServer.sh start 
# 2、关闭zk  
sh zkServer.sh stop
# 3、重启zk  
sh zkServer.sh restart
# 4、查看zk 运行状态 （可以判断是leader还是follower）
sh bin/zkServer.sh status

10、kafka启动等脚本：

# 启动
bin/zookeeper-server-start.sh config/zookeeper.properties &

11、在启动之前,克隆结构如下。我们需要修改的地方：

# 192.168.253.131:9092 改为下面对应的ip
listeners=PLAINTEXT://192.168.253.131:9092
# 0 改为下面对应的值myid
broker.id=0

还要修改zk集群下的data目录中指定的myid。

现在可返回9、10启动。先将zk集群全部启动好，在启动kafka。主要启动失败可能是防火墙或者端口未打开。至于测试这里就先不管了。

我们来利用docker模拟zk+kafka上述过程：
docker拉取：docker pull zookeeper:3.4.14
内部测试：

# always 一直启动是一定要的
root@ubuntu:~# docker run --name some-zookeeper --restart always -d zookeeper:3.4.14
54446ac6f3f2184e7fd569ba2f1dbdf065b7ab6172a3d2ba84e15973d0ab261c
root@ubuntu:~# docker ps | grep 'zookeeper'
54446ac6f3f2        zookeeper:3.4.14    "/docker-entrypoint.…"   6 minutes ago       Up 5 minutes        2181/tcp, 2888/tcp, 3888/tcp                       some-zookeeper
root@ubuntu:~# docker exec -it 54446ac6f3f2 /bin/bash
root@54446ac6f3f2:/zookeeper-3.4.14# ls
LICENSE.txt	      build.xml        lib			 zookeeper-3.4.14.jar.md5   zookeeper-it
NOTICE.txt	      conf	       pom.xml			 zookeeper-3.4.14.jar.sha1  zookeeper-jute
README.md	      dist-maven       src			 zookeeper-client	    zookeeper-recipes
README_packaging.txt  ivy.xml	       zookeeper-3.4.14.jar	 zookeeper-contrib	    zookeeper-server
bin		      ivysettings.xml  zookeeper-3.4.14.jar.asc  zookeeper-docs

创建zookeeper的docker网络：

root@ubuntu:/home/script/zookeeper# docker network create zookeeper --subnet 172.28.0.0/16
816a08963f357b38f720e86e52e73bdbf8c4f62b9ddf8b4ed6c012ea0f48fb64

脚本化处理：
创建放zk的脚本的目录：

root@ubuntu:/home/script# mkdir zookeeper
root@ubuntu:/home/script# ls
redis  zookeeper
root@ubuntu:/home/script/zookeeper# vim zoo.sh

# zookeeper创建数据data和配置文件conf目录
for port in $(seq 1 3);\
do \
mkdir -p /mydata/zookeeper/node-${port}/conf
mkdir -p /mydata/zookeeper/node-${port}/data
touch /mydata/zookeeper/node-${port}/conf/zoo.cfg
cat <<EOF> /mydata/zookeeper/node-${port}/conf/zoo.cfg
clientPort=2181 
dataDir=/data 
dataLogDir=/data/log 
tickTime=2000 
initLimit=5 
syncLimit=2 
autopurge.snapRetainCount=3 
autopurge.purgeInterval=0 
maxClientCnxns=60 
# 脚本server.1数字范围在0-255
server.1=172.28.0.11:2888:3888 
server.2=172.28.0.22:2888:3888 
server.3=172.28.0.23:2888:3888
EOF
done

创建myid文件：其余目录类似。

root@ubuntu:/mydata/zookeeper/node-1/data# vim myid

1

root@ubuntu:/mydata/zookeeper# find -name 'myid'
./node-2/data/myid
./node-3/data/myid
./node-1/data/myid

有空继续