五阶段--Docker 案例 / Docker搭建redis主从+哨兵/ Docker 搭建redis集群

目录

一 关闭防火墙

二 启动或重启docker

三 redis

 1 加载镜像

2 启动容器

四 jedis 连接redis服务测试

1 idea中新建测试项目

2  pom.xml

3  编写测试类

4 在容器中查看数据

5  启动多个 redis 容器

6 jedis 分片测试--将数据分散到指定的多个服务器中

7 在容器中查看数据

五 容器互联

 创建docker虚拟网络

六  mysql

1  加载 mariadb 镜像

2 创建数据卷

3 启动 mariadb 容器,并挂载数据卷

 4 进入容器,登录mysql测试

5 连接数据库,导入数据

七 tomcat

1 加载 tomcat 镜像

2 启动 tomcat 容器

3 访问测试

八 Docker搭建redis主从+哨兵

1 redis 哨兵

2 搭建主从服务器 —— 一主两从

3 启动哨兵

4 客户端api连接哨兵存取数据

九   Docker 搭建redis集群

---

一 关闭防火墙

# 关闭防火墙
systemctl stop firewalld.service
# 禁止防火墙开机启动
systemctl disable firewalld.service

二 启动或重启docker

# 启动docker
systemctl start docker

# 重启docker
systemctl restart docker

# 清理容器
 docker rm -f $(docker ps -aq)  

# 删除虚拟网络
docker network rm my-net

三 redis

 1 加载镜像

docker load < redis-docker-image.gz

2 启动容器

docker run -d --name redis7000 -p 7000:6379 redis

四 jedis 连接redis服务测试

1 idea中新建测试项目

空Project-->maven工程redis-api

2  pom.xml

• 添加 redis 和 junit 依赖:

<dependencies>
  	<dependency>
  		<groupId>redis.clients</groupId>
  		<artifactId>jedis</artifactId>
  		<version>2.9.0</version>
  	</dependency>
  	<dependency>
  		<groupId>junit</groupId>
  		<artifactId>junit</artifactId>
  		<version>4.12</version>
  	</dependency>
  </dependencies>

3  编写测试类

package docker;

import org.junit.Test;
import redis.clients.jedis.Jedis;

public class Test1 {
	@Test
	public void test1() {
		Jedis j = new Jedis("192.168.64.150", 7000);
		j.set("key1", "value1");
		
		String v = j.get("key1");
		System.out.println(v);
		
		j.close();
	}
}

4 在容器中查看数据

# 进入容器
docker exec -it redis7000 bash

# 运行redis客户端工具
redis-cli

127.0.0.1:6379> keys *
1) "key1"
127.0.0.1:6379> get key1
"value1"

5  启动多个 redis 容器

启动三个redis容器,将端口分别映射到7000,7001和7002端口

# 如果7000已经启动,不必重复启动
docker run -d --name redis7000 -p 7000:6379 redis

docker run -d --name redis7001 -p 7001:6379 redis
docker run -d --name redis7002 -p 7002:6379 redis

# 查看容器
docker ps -a

[root@localhost ~]# docker ps -a
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                    NAMES
756f5227dd64        redis               "docker-entrypoint.s…"   6 seconds ago       Up 4 seconds        0.0.0.0:7001->6379/tcp   redis7001
bc87e35664c8        redis               "docker-entrypoint.s…"   13 seconds ago      Up 11 seconds       0.0.0.0:7002->6379/tcp   redis7002
c3700e3e4c73        redis               "docker-entrypoint.s…"   2 hours ago         Up 2 hours          0.0.0.0:7000->6379/tcp   redis7000

6 jedis 分片算法测试--将数据分散到指定的多个服务器中

使用的是一致性哈希算法,哈希环

• 编写测试方法

	@Test
	public void test2() {
		JedisPoolConfig cfg = new JedisPoolConfig();
		cfg.setMaxTotal(500);
		cfg.setMaxIdle(20);
		
		List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
		shards.add(new JedisShardInfo("192.168.64.150", 7000));
		shards.add(new JedisShardInfo("192.168.64.150", 7001));
		shards.add(new JedisShardInfo("192.168.64.150", 7002));
		
		ShardedJedisPool pool = new ShardedJedisPool(cfg, shards);
		
		ShardedJedis j = pool.getResource();
		for (int i = 0; i < 100; i++) {
			j.set("key"+i, "value"+i);
		}
		
		pool.close();
	}

注意:docker命令要启动三个redis服务,idea才能成功连接,少一个都会连接异常

• 也可以在main方法测试:

package test;

import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;

import java.util.ArrayList;
import java.util.List;

public class Test1 {
    public static void main(String[] args) {
        // 服务地址列表 --分片服务器信息
        List<JedisShardInfo> list = new ArrayList<JedisShardInfo>();
        list.add(new JedisShardInfo("192.168.64.150",7000));
        list.add(new JedisShardInfo("192.168.64.150",7001));
        list.add(new JedisShardInfo("192.168.64.150",7002));
        // 配置参数对象
        JedisPoolConfig conf = new JedisPoolConfig();
        // 创建包含三个redis服务器地址的连接池
        ShardedJedisPool pool = new ShardedJedisPool(conf,list);
        // 从连接池创建一个数据操作工具对象
        ShardedJedis j = pool.getResource();
        // 添加100条数据,分散存放在三个redis服务
        for (int i = 0; i < 100; i++) {
            j.set("k"+i, "v"+i);
        }
    }
}

7 在容器中查看数据

分别进入三个redis容器,执行 keys *查看结果,100条数据会分散到三个redis服务中,分别各占34个,33个,33个

docker exec -it redis7000 redis-cli
docker exec -it redis7001 redis-cli
docker exec -it redis7002 redis-cli

五 容器互联

 创建docker虚拟网络

# 删除创建的网络 my-net
docker network rm my-net

# 清理容器
docker rm -f $(docker ps -aq)

# subnet 子网网段  创建网络
docker network create --subnet=172.18.0.0/24 dockernet  

#查看所有网络
docker network ls

# 查看所有配置
ifconfig

六  部署mysql,导入项目数据库

1  加载 mariadb 镜像

docker load < mariadb-docker-image.gz

2 创建数据卷

docker volume create mysql-data

3 启动 mariadb 容器,并挂载数据卷并端口映射到3306

# /var/lib/mysql 数据挂载的路径  -e 配置环境变量参数,多个配置需要多个-e
docker run -d --name mysql --net dockernet --ip 172.18.0.11 -v mysql-data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=root -p 3306:3306 mariadb

docker ps -a

docker inspect mysql

 4 进入容器,登录mysql测试

docker exec -it mysql bash

mysql -uroot -p

5 连接数据库,导入数据

•  选择 资料/docker/EasyMall/easymall.sql

七   tomcat--启动web应用

1 加载 tomcat 镜像

docker load < tomcat7-docker-image.gz

docker image ls

• opt目录下创建easymall文件,拉取ROOT.WAR文件到此文件夹下

2 启动 tomcat 容器

# 配置tomcat 并启动
docker run -d --name web \
--restart=always \
-v /opt/easymall:/usr/local/tomcat/webapps \
-p 80:8080 \
--net=dockernet \
--ip=172.18.0.12 \
tomcat


#项目测试访问,端口号默认80
http://192.168.64.150

3 访问测试

八 Docker搭建redis主从+哨兵

1 redis 哨兵

redis主从复制结构中，当主服务器宕机，哨兵可以监控到服务宕机，在从服务器中选举产生一个新的主服务器。

2 搭建主从服务器 —— 一主两从

• 清理容器（可选）

docker rm -f $(docker ps -aq)

• 启动主服务器

# --net=host 容器直接使用宿主机的端口，不需要做端口映射
docker run -d --name redis6379 --net=host --restart=always redis 

# 进入容器，运行redis客户端
docker exec -it redis6379 redis-cli

# 查看集群信息，默认是主服务器
> info replication

• 启动两个从服务器

# 启动redis6380容器，作为 redis6379 的从服务器启动
# --port 和 --slaveof 是 redis-server 命令的参数
docker run -d --name redis6380 --net=host --restart=always redis \
redis-server --port 6380 --slaveof 192.168.64.150 6379

# 启动redis6381容器，作为 redis6379 的从服务器启动
docker run -d --name redis6381 --net=host --restart=always redis \
redis-server --port 6381 --slaveof 192.168.64.150 6379

# 查看三个 redis 服务的角色
docker exec -it redis6379 redis-cli
> info replication

docker exec -it redis6380 redis-cli -p 6380
> info replication

docker exec -it redis6381 redis-cli -p 6381
> info replication

其中: 主服务设置的数据,两个从服务器都有,可以通过keys*查看

3 启动哨兵

• 哨兵的配置文件

mkdir /opt/sentinel/
cd /opt/sentinel/

# 配置文件中的 "sentinel monitor mymaster 192.168.64.150 6379 2"
# 末尾的 2 表示两个哨兵从服务器投票确认主服务器宕机，哨兵才会认为主服务器宕机
cat <<EOF >5000.conf
port 5000
sentinel monitor mymaster 192.168.64.150 6379 2
sentinel down-after-milliseconds mymaster 5000
sentinel failover-timeout mymaster 60000
sentinel parallel-syncs mymaster 1
EOF

cat <<EOF >5001.conf
port 5001
sentinel monitor mymaster 192.168.64.150 6379 2
sentinel down-after-milliseconds mymaster 5000
sentinel failover-timeout mymaster 60000
sentinel parallel-syncs mymaster 1
EOF

cat <<EOF >5002.conf
port 5002
sentinel monitor mymaster 192.168.64.150 6379 2
sentinel down-after-milliseconds mymaster 5000
sentinel failover-timeout mymaster 60000
sentinel parallel-syncs mymaster 1
EOF

• 启动三个哨兵

docker run -d --name sentinel5000 \
-v /opt/sentinel/5000.conf:/sentinel.conf \
--net=host \
redis redis-sentinel /sentinel.conf

docker run -d --name sentinel5001 \
-v /opt/sentinel/5001.conf:/sentinel.conf \
--net=host \
redis redis-sentinel /sentinel.conf

docker run -d --name sentinel5002 \
-v /opt/sentinel/5002.conf:/sentinel.conf \
--net=host \
redis redis-sentinel /sentinel.conf

# 进入一个哨兵容器，查看它监控的主从服务器和其他哨兵  # mymaster是集群名
docker exec -it sentinel5000 redis-cli -p 5000
> sentinel master mymaster        #查看主服务器
> sentinel slaves mymaster        #查看从服务器
> sentinel sentinels mymaster     #查看其他两个哨兵 

• 停止主服务器，测试主服务器重新选举

# 停止主服务器
docker stop redis6379
# 在哨兵日志中查看服务器切换日志： +switch-master mymaster 192.168.64.150 6379 192.168.64.150 6381
docker logs sentinel5000

# 查看 6380 和 6381 服务器的角色变化  ,两个会有一个变成主服务器
docker exec -it redis6380 redis-cli -p 6380
> info replication

docker exec -it redis6381 redis-cli -p 6381
> info replication

• 重新启动6379，不会把6379切换成主服务器，而是作为从服务器

docker start redis6379

docker exec -it redis6379 redis-cli
> info replication

4 客户端api连接哨兵存取数据

package test;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisSentinelPool;
import java.util.HashSet;
import java.util.Set;

public class Test2 {
    public static void main(String[] args) {
        // 哨兵服务器列表
        Set<String> set = new HashSet<String>();
        set.add("192.168.64.150:5000");
        set.add("192.168.64.150:5001");
        set.add("192.168.64.150:5002");
        // 配置对象
        JedisPoolConfig conf = new JedisPoolConfig();
        // 哨兵连接池
        JedisSentinelPool p =
                new JedisSentinelPool("mymaster", set, conf);
        // 数据操作工具
        Jedis j = p.getResource();
        j.set("k1","v1");
    }
}

九   Docker 搭建redis集群(cluster)

Redis有三种集群模式，分别是：

* 主从模式

* Sentinel模式

* Cluster模式

以下是redis主从集群模式:三主三从

六个Redis实例的配置文件：
redis.conf

port 7000
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes

/opt/redis
		/7000/redis.conf
		/7001/redis.conf
		/7002/redis.conf
		/7003/redis.conf
		/7004/redis.conf
		/7005/redis.conf

mkdir /opt/redis
cd /opt/redis
mkdir 7000 7001 7002 7003 7004 7005

cat <<EOF >7000/redis.conf
port 7000
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
EOF

cat <<EOF >7001/redis.conf
port 7001
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
EOF

cat <<EOF >7002/redis.conf
port 7002
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
EOF

cat <<EOF >7003/redis.conf
port 7003
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
EOF

cat <<EOF >7004/redis.conf
port 7004
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
EOF

cat <<EOF >7005/redis.conf
port 7005
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
EOF

• 先启动6个redis实例:

docker run -d --name redis7000 \
-v /opt/redis/7000/redis.conf:/redis.conf \
--net=host \
--restart=always \
redis \
redis-server /redis.conf

docker run -d --name redis7001 \
-v /opt/redis/7001/redis.conf:/redis.conf \
--net=host \
--restart=always \
redis \
redis-server /redis.conf

docker run -d --name redis7002 \
-v /opt/redis/7002/redis.conf:/redis.conf \
--net=host \
--restart=always \
redis \
redis-server /redis.conf

docker run -d --name redis7003 \
-v /opt/redis/7003/redis.conf:/redis.conf \
--net=host \
--restart=always \
redis \
redis-server /redis.conf

docker run -d --name redis7004 \
-v /opt/redis/7004/redis.conf:/redis.conf \
--net=host \
--restart=always \
redis \
redis-server /redis.conf

docker run -d --name redis7005 \
-v /opt/redis/7005/redis.conf:/redis.conf \
--net=host \
--restart=always \
redis \
redis-server /redis.conf

• 集群模式下,单独启动每个服务,此时每个服务都不可用,

• 执行命令配置集群

# 进入容器执行集群配置命令   # --cluster-replicas 1  每个主服务器带一个从服务器

docker exec -it redis7000 \
redis-cli --cluster create \
192.168.64.150:7000 192.168.64.150:7001 \
192.168.64.150:7002 192.168.64.150:7003 \
192.168.64.150:7004 192.168.64.150:7005 \
--cluster-replicas 1

 ​​​

• 查看集群信息

# -c 代表以集群模式进入
docker exec -it redis7000 redis-cli -c -p 7000

cluster info

cluster nodes

 ​​​​​

• 存数据 ,三个主服务随机存储数据,你要获取哪个key,就会指出这个key对应的值和存储主服务

docker exec -it redis7000 redis-cli -c -p 7000
# 7002
set a aaaaaaaaaaaaa
# 7000
set b bbbbbbbbbbb
# 7001
set c cccccccccccccccc

• idea中创建spring Initalizr工程,添加spring-data-redis依赖

1.pom.xml

 

 2.配置文件,后缀改为.yml并配置redis集群节点

spring:
  redis:
    cluster:
      nodes:
        - 192.168.64.150:7000
        - 192.168.64.150:7001
        - 192.168.64.150:7002
        - 192.168.64.150:7003
        - 192.168.64.150:7004
        - 192.168.64.150:7005

3.测试包下编辑

    @Autowired
    private RedisConnectionFactory f;

    @Test
    public void test(){
        // 集群连接对象
        RedisClusterConnection c = f.getClusterConnection();
        c.set("k1".getBytes(),"v1".getBytes());//键值都以数组格式存储
    }

4.启动测试类后,在redis主服务器上获取键值

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        
        
spring:
  redis:
    cluster:
      nodes:
        - 192.168.64.150:7000
        - 192.168.64.150:7001
        - 192.168.64.150:7002
        - 192.168.64.150:7003
        - 192.168.64.150:7004
        - 192.168.64.150:7005
        
        
    @Autowired
    private RedisConnectionFactory connectionFactory;

    public void test() {
        RedisClusterConnection c = connectionFactory.getClusterConnection();
        for (int i = 0; i < 100; i++) {
            c.set(("k"+i).getBytes(StandardCharsets.UTF_8),
                    ("v"+i).getBytes(StandardCharsets.UTF_8));
        }
    }
    
    
    @Autowired
    @Qualifier("stringRedisTemplate")
    private RedisTemplate t;

    public void test() {
        ValueOperations<String, Object> o = t.opsForValue();
        o.set("hhhh", "vvvv");
        o.set("nnnn", "gggg");
    }