docker学习笔记

1、简介

Docker是一个开源的应用容器引擎；是一个轻量级容器技术；

Docker支持将软件编译成一个镜像；然后在镜像中各种软件做好配置，将镜像发布出去，其他使用者可以直接使用这个镜像；

运行中的这个镜像称为容器，容器启动是非常快速的。

2、核心概念

docker主机(Host)：安装了Docker程序的机器（Docker直接安装在操作系统之上）；

docker客户端(Client)：连接docker主机进行操作；

docker仓库(Registry)：用来保存各种打包好的软件镜像；

docker镜像(Images)：软件打包好的镜像；放在docker仓库中；

docker容器(Container)：镜像启动后的实例称为一个容器；容器是独立运行的一个或一组应用

使用Docker的步骤：

1）、安装Docker

2）、去Docker仓库找到这个软件对应的镜像；

3）、使用Docker运行这个镜像，这个镜像就会生成一个Docker容器；

4）、对容器的启动停止就是对软件的启动停止；

3、安装Docker

1）、安装linux虚拟机（或者使用阿里云服务器）

​ 1）、VMWare、VirtualBox（安装）；

​ 2）、导入虚拟机文件；

​ 3）、双击启动linux虚拟机;使用 root/ 123456登陆

​ 4）、使用客户端连接linux服务器进行命令操作；

​ 5）、设置虚拟机网络；

​ 桥接网络=选好网卡==接入网线；

​ 6）、设置好网络以后使用命令重启虚拟机的网络

service network restart

​ 7）、查看linux的ip地址

ip addr

​ 8）、使用客户端连接linux；

2）、在linux虚拟机上安装docker

一、配置阿里云yum源（提高docker软件下载速度）： 参考连接
1、备份

mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup

2、下载新的CentOS-Base.repo 到/etc/yum.repos.d/
CentOS 7

wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo

或者

curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo

3、生成新的缓存

yum clean all
yum makecache
yum update

二、安装docker步骤：

1、检查内核版本，必须是3.10及以上
uname -r

2、使用 root 权限登录 Centos。确保 yum 包更新到最新。
yum update

3、卸载旧版本(如果安装过旧版本的话)
$ yum remove docker  docker-common docker-selinux docker-engine

4、安装需要的软件包， yum-util 提供yum-config-manager功能，另外两个是devicemapper驱动依赖的
$ yum install -y yum-utils device-mapper-persistent-data lvm2

5、设置yum源
$ sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

6、可以查看所有仓库中所有docker版本，并选择特定版本安装
$ yum list docker-ce --showduplicates | sort -r

7、安装docker
$  yum install docker-ce-17.12.0.ce #由于repo中默认只开启stable仓库，这里安装的是稳定版17.12.0

8、启动docker
[root@localhost ~] systemctl start docker
[root@localhost ~] docker -v
Docker version 1.12.6, build 3e8e77d/1.12.6

9、开机启动docker
[root@localhost ~] systemctl enable docker
Created symlink from /etc/systemd/system/multi-user.target.wants/docker.service to /usr/lib/systemd/system/docker.service.

10、停止docker
systemctl stop docker

4、Docker常用命令&操作

1）、镜像操作

操作	命令	说明
检索	docker search 关键字 eg：docker search redis	我们经常去docker hub上检索镜像的详细信息，如镜像的TAG。
拉取	docker pull 镜像名:tag	:tag是可选的，tag表示标签，多为软件的版本，默认是latest
列表	docker images	查看所有本地镜像
删除	docker rmi image-id	删除指定的本地镜像

镜像查找： https://hub.docker.com/（包含具体镜像的操作命令）
docker改国内官方镜像(提升镜像pull速度):
编辑文件/etc/docker/daemon.json，没有就新建。加入以下项目

{
    "registry-mirrors": ["https://registry.docker-cn.com","http://hub-mirror.c.163.com"]
}

本身daemon.json文件已经有项目，就额外增加registry-mirrors项

重启docker daemon

systemctl restart docker 

2）、容器操作

软件镜像（QQ安装程序）----运行镜像----产生一个容器（正在运行的软件，运行的QQ）；

步骤：

1、搜索镜像
[root@localhost ~] docker search tomcat
2、拉取镜像
[root@localhost ~] docker pull tomcat
3、根据镜像启动容器
docker run --name mytomcat -d tomcat:latest
4、docker ps  
查看运行中的容器
5、 停止运行中的容器
docker stop  容器的id
6、查看所有的容器（包括没有运行的）
docker ps -a
7、启动容器
docker start 容器id
8、删除一个容器
 docker rm 容器id
9、启动一个做了端口映射的tomcat
[root@localhost ~]# docker run -d -p 8888:8080 tomcat
-d：后台运行
-p: 将主机的端口映射到容器的一个端口    主机端口:容器内部的端口

10、为了演示简单关闭了linux的防火墙
service firewalld status ；查看防火墙状态
service firewalld stop：关闭防火墙
11、查看容器的日志
docker logs container-name/container-id

更多命令参看
https://docs.docker.com/engine/reference/commandline/docker/
可以参考每一个镜像的文档

3）、安装MySQL示例

docker pull mysql:5.7

正确的启动：做了端口映射

[root@localhost ~]# docker run -p 3306:3306 --name mysql02 -e MYSQL_ROOT_PASSWORD=123456 -d mysql
ad10e4bc5c6a0f61cbad43898de71d366117d120e39db651844c0e73863b9434
[root@localhost ~]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                    NAMES
ad10e4bc5c6a        mysql               "docker-entrypoint.sh"   4 seconds ago       Up 2 seconds        0.0.0.0:3306->3306/tcp   mysql02

几个其他的高级操作

docker run --name mysql03 -v /conf/mysql:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag
把主机的/conf/mysql文件夹挂载到 mysqldocker容器的/etc/mysql/conf.d文件夹里面
改mysql的配置文件就只需要把mysql配置文件放在自定义的文件夹下（/conf/mysql）

docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci
指定mysql的一些配置参数

docker安装mysql后外部无法访问，解决办法：

1. 记得开启阿里云相应的端口号
2. 修改权限

使用bash窗口
docker exec -it mysqlDB bash

登陆mysql
mysql -uroot -p123456;

修改权限
> use mysql;
> update user set authentication_string = password('123456') where user = 'root';
> grant all privileges on *.* to 'root'@'%' identified by '123456' with grant option;
> flush privileges;
> exit;

4）、安装redis

docker pull redis:5.0.7

正确的启动：做了端口映射

[root@localhost ~] docker run -d -p 6381:6379 --name myredis  redis:5.0.7 --requirepass "123456"
# --requirepass "123456" 设置密码
# -p 6381:6379：映射容器服务的 6379 端口到宿主机的 681 端口。外部可以直接通过宿主机ip:6381 访问到 Redis 的服务
[root@localhost ~] docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                               NAMES
dff3d4e7ef6b        redis:5.0.7         "docker-entrypoint.s…"   16 minutes ago      Up 16 minutes       0.0.0.0:6381->6379/tcp              myredis
[root@localhost ~] docker exec -it myredis bash 
#docker exec -it xxx bash 这个命令是表示进入容器的，xxx是服务名称也可以是容器的id

几个其他的高级操作

# docker run -p 6382:6379 --name myredis -v $PWD/redis.conf:/etc/redis/redis.conf -v $PWD/data:/data -d redis:5.0.7 redis-server /etc/redis/redis.conf --appendonly yes
　　命令说明：
　　--name myredis : 指定容器名称，这个最好加上，不然在看docker进程的时候会很尴尬。
　　-p 6699:6379 ： 端口映射，默认redis启动的是6379，至于外部端口，随便玩吧，不冲突就行。
　　-v $PWD/redis.conf:/etc/redis/redis.conf ： 将主机中当前目录下的redis.conf配置文件映射。
　　-v $PWD/data:/data -d redis:3.2 ： 将主机中当前目录下的data挂载到容器的/data
　　--redis-server --appendonly yes :在容器执行redis-server启动命令，并打开redis持久化配置\

docker安装redis后外部无法访问，解决办法： 记得开启阿里云相应的端口号.

5）、安装Elasticsearch

参考文章：https://blog.csdn.net/qq_32101993/article/details/100021002
拉取镜像：

docker pull elasticsearch:tag(6.8.5)

启动：

[root@localhost ~] docker run -d  -e  ES_JAVA_OPTS="-Xms256m -Xmx256m"   -p 9200:9200   -p 9300:9300  --name ES01  elasticsearch:版本号(如果是latest则不写) 
[root@localhost ~] docker ps
# 查看是否成功
CONTAINER ID        IMAGE                 COMMAND                  CREATED             STATUS              PORTS                                            NAMES
c3f23945d1ed        elasticsearch:6.8.5   "/usr/local/bin/dock…"   6 minutes ago       Up 53 seconds       0.0.0.0:9200->9200/tcp, 0.0.0.0:9300->9300/tcp   ES01

此时已经可以正常外部访问网址：域名:端口号

配置跨域：

1.首先进入容器
docker exec -it ES01 /bin/bash
2.安装vim
yum -y install vim*
3.编辑/config/elasticsearch.ym
vim elasticsearch.yml 
4.添加内容
cluster.name: "qfcwx-cluster"   
network.host: 0.0.0.0
http.cors.enabled: true
http.cors.allow-origin: "*"
5.exit
6.重启
docker restart ES01(容器id或者name)

1. cluster.name：自定义集群名称。
2. network.host：当前es节点绑定的ip地址，默认127.0.0.1，如果需要开放对外访问这个属性必须设置。
3. http.cors.enabled：是否支持跨域，默认为false。
4. http.cors.allow-origin：当设置允许跨域，默认为*，表示支持所有域名，如果我们只是允许某些网站能访问，那么可以使用正则表达式。

访问截图：

5）、安装rabbitMQ

参考文章：https://www.cnblogs.com/yufeng218/p/9452621.html
拉取镜像：选择带有mangement的版本（包含web管理页面）

docker pull rabbitmq:management

启动：

[root@localhost ~] docker run -d --name rabbitmq -p 5672:5672 -p 15672:15672 -v `pwd`/data:/var/lib/rabbitmq --hostname myRabbit -e RABBITMQ_DEFAULT_VHOST=my_vhost  -e RABBITMQ_DEFAULT_USER=admin -e RABBITMQ_DEFAULT_PASS=admin 6bd1749b8197
[root@izlnxqoeytyh4fz ~]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                                                                                         NAMES
c6575d289410        6bd1749b8197        "docker-entrypoint.s…"   6 seconds ago       Up 4 seconds        4369/tcp, 5671/tcp, 15671/tcp, 25672/tcp, 0.0.0.0:15672->15672/tcp, 0.0.0.0:15673->5672/tcp   rabbitmq

• -v 映射目录或文件；
• –hostname 主机名（RabbitMQ的一个重要注意事项是它根据所谓的 “节点名称” 存储数据，默认为主机名）；
• -e 指定环境变量；（RABBITMQ_DEFAULT_VHOST：默认虚拟机名；RABBITMQ_DEFAULT_USER：默认的用户名；RABBITMQ_DEFAULT_PASS：默认用户名的密码）

# 进入控制台
docker exec -it rabbitmq  /bin/bash

此时已经可以正常外部访问网址：域名:端口号

访问截图：

6）、安装Jenkins

参考官方安装方法
拉取镜像：

# docker官方的已经不推荐，故选择Jenkins提供的
docker pull jenkins/jenkins

启动：

[root@localhost ~] docker run -d -v jenkins_home:/var/jenkins_home -p 8080:8080 -p 50000:50000 jenkins/jenkins
# 进入控制台
docker exec -it jenkins/jenkins  /bin/bash

5、集群

（1）mysql集群搭建

一、参考文章

• mysql集群搭建方式
• 负载均衡参考博客
• 搭建参考博客
• 流程图知识点
• 
• 

二、搭建流程

1. 拉取镜像

docker pull percona/percona-xtradb-cluster:5.7

2. 名字太长了，改短了

docker tag percona/percona-xtradb-cluster:5.7  pxc
# 删除
docker rmi percona/percona-xtradb-cluster:5.7

3. 创建内部网络
   说明： 出于安全考虑，将PXC集群放置于docker内部网络中。只需将宿主的端口与之映射并开放出来即可。

docker network create --subnet=172.18.0.0/24 net1

执行成功后，执行如下命令 查看net1详细信息：

docker inspect net1

输出如下：

[
    {
        "Name": "net1",
        "Id": "68c2a6f28da4bcc841b2caac3d414c66c5017f71a5050f84d26d023d98253452",
        "Created": "2019-12-25T19:15:07.837735721+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": {},
            "Config": [
                {
                    "Subnet": "172.18.0.0/24"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Ingress": false,
        "ConfigFrom": {
            "Network": ""
        },
        "ConfigOnly": false,
        "Containers": {},
        "Options": {},
        "Labels": {}
    }
]

说明： –subnet=172.18.0.0/24 自定义网段172.18.0.0，24是指24位子网掩码 net1 网段名称。
4. 创建docker卷
说明： docker容器的运行规则：通过目录映射的方法，将业务数据写入到宿主机中。好处是如果容器故障，只需将容器删除，重新启用一个容器即可，这样就不会丢失原来的数据。
由于PXC较为特殊，无法直接使用映射目录的方法做映射（使用后会闪退），故使用docker卷。

docker volume create --name v1
# 执行成功后，想查看映射的地址，可通过如下命令进行查看：
docker inspect v1
# 执行上面命令输出：
[
    {
        "CreatedAt": "2019-12-25T19:15:41+08:00",
        "Driver": "local",
        "Labels": {},
        "Mountpoint": "/var/lib/docker/volumes/v1/_data",
        "Name": "v1",
        "Options": {},
        "Scope": "local"
    }
]

可以看到Mountpoint字段 就是映射在宿主机的路径。
用于后续会在不同容器中一使用不同的docker卷，故再这预先执行以下命令：

docker volume create --name v2
docker volume create --name v3
docker volume create --name v4

5. 创建PXC容器

docker run -d -p 3306:3306 -v v1:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -e CLUSTER_NAME=PXC -e XTRABACKUP_PASSWORD=123456 --privileged --name=node1 --net=net1 --ip 172.18.0.2 pxc

说明：

-d  默认在后台运行
-p  3306（宿主）:3306（容器）   端口映射，将容器3306端口映射到宿主3306坤口
-v  目录映射，将第四步创建的v1映射到容器/var/lib/mysql
-e MYSQL_ROOT_PASSROWD  创建的用户实例的密码，默认实例root
-e CLUSTER_NAME  集群名称
-e XTRABACKUP_PASSWORD  数据库之间同步使用的密码
--privileged  权限.给予最高权限
--name 给容器容命名
--net 使用内部网段
--ip 内部网段分到的地址
pxc 指的是镜像

说明： 在创建第一个容器时 初始化数据库需要一点时间（两分钟左右），不可过快执行创建下方容器命令。是由于第一个mysql还未初始化启动完成，无法找到对应节点造成闪退。

创建其余容器：

docker run -d -p 3307:3306 -v v2:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -e CLUSTER_NAME=PXC -e XTRABACKUP_PASSWORD=123456 -e CLUSTER_JOIN=node1 --privileged --name=node2 --net=net1 --ip 172.18.0.3 pxc

docker run -d -p 3308:3306 -v v3:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -e CLUSTER_NAME=PXC -e XTRABACKUP_PASSWORD=123456 -e CLUSTER_JOIN=node1 --privileged --name=node3 --net=net1 --ip 172.18.0.4 pxc

docker run -d -p 3309:3306 -v v4:/var/lib/mysql -e MYSQL_ROOT_PASSROWD=123456 -e CLUSTER_NAME=PXC -e XTRABACKUP_PASSWORD=123456 -e CLUSTER_JOIN=node1 --privileged --name=node4 --net=net1 --ip 172.18.0.5 pxc

6. 验证是否创建成功PCX集群
   用Navicat for mysql连接到之前四个节点的数据库，在四个节点数据库中 在任意一个数据库进行建库、建表、增删改查数据等操作后，再查看其它节点进行查看，或者在其它不同的节点进行操作看是否数据能成功进行同步。
   
7. 启动失败解决方法
   参考文章

# 查看日志
docker logs node1
# 错误日志
[ERROR] WSREP: It may not be safe to bootstrap the cluster from this node. It was not the last one to leave the cluster and may not contain all the updates. To force cluster bootstrap with this node, edit the grastate.dat file manually and set safe_to_bootstrap to 1 .

集群本身无问题，只是非正常关闭。
修改想第一个启动节点的grastate.dat文件，将safe_to_bootstrap: 0 改为 1

#查看v1位置
docker inspect v1
# 执行上面命令输出：
[
    {
        "CreatedAt": "2019-12-25T19:15:41+08:00",
        "Driver": "local",
        "Labels": {},
        "Mountpoint": "/var/lib/docker/volumes/v1/_data",
        "Name": "v1",
        "Options": {},
        "Scope": "local"
    }
]
cd /var/lib/docker/volumes/v1/_data
vi grastate.dat

8. 附录

# docker 删除网关net1
docker network rm  net1
#docker 删除docker卷v1
docker volume rm v1

三、安装Haproxy进行高可用与负载均衡

• 拉取镜像

docker pull haproxy

• 编写Haproxy配置文件

# 确保路径上文件夹已经创建了
vi /home/guest/haproxy.cfg

配置文件内容：

global
    #工作目录
    chroot /usr/local/etc/haproxy
    #日志文件，使用rsyslog服务中local5日志设备（/var/log/local5），等级info
    log 127.0.0.1 local5 info
    #守护进程运行
    daemon
defaults
    log global
    mode    http
    #日志格式
    option  httplog
    #日志中不记录负载均衡的心跳检测记录
    option  dontlognull
    #连接超时（毫秒）
    timeout connect 5000
    #客户端超时（毫秒）
    timeout client  50000
    #服务器超时（毫秒）
    timeout server  50000
#监控界面   
listen  admin_stats
    #监控界面的访问的IP和端口
    bind  0.0.0.0:8888
    #访问协议
    mode        http
    #URI相对地址
    stats uri   /dbs
    #统计报告格式
    stats realm     Global\ statistics
    #登陆帐户信息
    stats auth  admin:123456
#数据库负载均衡
listen  proxy-mysql
    #访问的IP和端口
    bind  0.0.0.0:3306  
    #网络协议
    mode  tcp
    #负载均衡算法（轮询算法）
    #轮询算法：roundrobin
    #权重算法：static-rr
    #最少连接算法：leastconn
    #请求源IP算法：source 
    balance  roundrobin
    #日志格式
    option  tcplog
    #在MySQL中创建一个没有权限的haproxy用户，密码为空。Haproxy使用这个账户对MySQL数据库心跳检测
    option  mysql-check user haproxy
    server  MySQL_1 172.18.0.2:3306 check weight 1 maxconn 2000  
    server  MySQL_2 172.18.0.3:3306 check weight 1 maxconn 2000  
    server  MySQL_3 172.18.0.4:3306 check weight 1 maxconn 2000 
    server  MySQL_4 172.18.0.5:3306 check weight 1 maxconn 2000
    server  MySQL_5 172.18.0.6:3306 check weight 1 maxconn 2000
    #使用keepalive检测死链
    option  tcpka

• 创建2个Haproxy负载均衡服务器(建两个的原因：高可用)

docker run -it -d -p 4001:8888 -p 4002:3306 -v /home/guest/haproxy:/usr/local/etc/haproxy --name h1 --privileged --net=net1 --ip 172.18.0.21 haproxy

docker run -it -d -p 4011:8888 -p 4012:3306 -v /home/guest/haproxy:/usr/local/etc/haproxy --name h2 --privileged --net=net1 --ip 172.18.0.22 haproxy

• 进入h1和h2容器，启动Haproxy

docker exec -it h1 bash
haproxy -f /usr/local/etc/haproxy/haproxy.cfg

docker exec -it h2 bash
haproxy -f /usr/local/etc/haproxy/haproxy.cfg

• 创建用户（不创建无法检测mysql集群心跳）

# mysql创建账号（前面配置文件haproxy.cfg提到--Haproxy使用这个账户对MySQL数据库心跳检测）
CREATE USER 'haproxy'@'%' IDENTIFIED BY '';

• 查看是否启动成功：

访问http://ip:4001/dbs（/dbs 在前面配置文件设置haproxy.cfg）

• 使用Haproxy中间件连接数据库(java项目使用这些属性连接mysql)
  
  注： 4002端口，就是启动haproxy操作中 -p 4002:3306 命令，将docker容器的3306端口映射给宿主机的4002端口，读者可自行替换。

接下来创建好haproxy数据连接，就可以在该haproxy数据库连接中进行数据库操作，haproxy会帮你将操作按照haproxy配置的策略分发到各个容器（node1，node2，node3，node4，node5）的数据库中，从而实现负载均衡。

• pxc启动脚本

vi pxc.sh
chmod +x pxc.sh
sh pxc.sh

pxc.sh

rm -f /var/lib/docker/volumes/v1/_data/grastate.dat
docker start node1
docker start node2
docker start node3
docker start node4
docker start node5
docker start h1
docker start h2

四、安装keepalive实现双击热备

1. 参考文章

• 安装步骤

• 安装步骤

• keepalived.conf配置详解

• mycat

2. 在两个容器中安装keepalived

先创建宿主机的keepalived.conf：

vrrp_instance  VI_1 {
    state  MASTER
    interface  eth0
    virtual_router_id  51
    priority  100
    advert_int  1
    authentication {
        auth_type  PASS
        auth_pass  123456
    }
    virtual_ipaddress {
        172.18.0.201
    }
}

#进入h1容器
docker exec -it h1 bash
#更新软件包
apt-get update
#安装Keepalived
apt-get install keepalived
#打开另一个终端，宿主机下拷贝配置文件到h1容器
docker cp keepalived.conf h1:/etc/keepalived/
#在容器中启动Keepalived
service keepalived start
#在宿主机执行ping命令
ping 172.18.8.11

在容器中查看你刚刚添加的虚拟网络172.168.0.201是否出现

能ping通就说明搭建成功了，即在h1 里面装好了keepalived。
我们还要在h2装keepalived，操作跟上面的一样。

3. 在h2中搭建完后，我们在宿主机中再安装一个keepalived

#安装软件
yum install -y keepalived
# 配置文件
vim /etc/keepalived/keepalived.conf
# 启动
systemctl start keepalived
#查看状态
systemctl status keepalived
#开机启动
systemctl enable keepalived.service

配置文件

vrrp_instance VI_1 {
    state MASTER
    interface ens33  #注意的地方:使用ens33
    virtual_router_id 51
    priority 100
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 1111
    }
    virtual_ipaddress {
        192.168.31.246
    }
}

virtual_server 192.168.31.246 8888 {
    delay_loop 3
    lb_algo rr
    lb_kind NAT
    persistence_timeout 50
    protocol TCP

    real_server 172.18.0.201 8888 {
        weight 1
    }
}

virtual_server 192.168.31.246 3306 {
    delay_loop 3
    lb_algo rr
    lb_kind NAT
    persistence_timeout 50
    protocol TCP

    real_server 172.18.0.201 3306 {
        weight 1
    }
}

到这里我们的5节点pxc集群就真正意义上的达到了高可用，有任何一个node挂掉都不影响客户访问其他数据库，就算有一个haproxy挂掉的话我们还有一个haproxy来实现负载均衡，还有keepalived来热备。之后我将更新搭载mycat实现高性能以及一些其它的方案。

（2）redis集群搭建

一、参考文章

redis的三种集群方式
安装文章参考
参考文章

二、搭建过程

• 拉取镜像

docker pull redis:5.0.7

• 创建虚拟网卡

docker network create redis-net
docker network ls
docker network inspect redis-net

• 创建

mkdir -p /home/redis-cluster
cd /home/redis-cluster
vi redis-cluster.tmpl

port ${PORT}
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-announce-ip 192.168.37.128
cluster-announce-port ${PORT}
cluster-announce-bus-port 1${PORT}
appendonly yes
protected-mode no

192.168.37.128 虚拟机IP（容器宿主机IP）
各节点解释如下所示：

port：节点端口，即对外提供通信的端口
cluster-enabled：是否启用集群
cluster-config-file：集群配置文件
cluster-node-timeout：连接超时时间
cluster-announce-ip：集群各节点IP地址
cluster-announce-port：集群节点映射端口
cluster-announce-bus-port：集群总线端口
appendonly：持久化模式

cluster-announce-ip: 这个IP需要特别注意一下，如果要对外提供访问功能，需要填写宿主机的IP，如果填写docker分配的IP（172.x.x.x），可能会导致部分集群节点在跳转时失败。

• 创建节点配置文件(create.sh)

for port in $(seq 8010 8015); \
do \
  mkdir -p ./${port}/conf  \
  && PORT=${port} envsubst < ./redis-cluster.tmpl > ./${port}/conf/redis.conf \
  && mkdir -p ./${port}/data; \
done

• 创建redis节点容器(run.sh)

for port in $(seq 8010 8015); \
do \
   docker run -it -d -p ${port}:${port} -p 1${port}:1${port} \
  --privileged=true -v /home/redis-cluster/${port}/conf/redis.conf:/usr/local/etc/redis/redis.conf \
  --privileged=true -v /home/redis-cluster/${port}/data:/data \
  --restart always --name redis-${port}  --net redis-net \
  --sysctl net.core.somaxconn=1024 redis:5.0.7   redis-server /usr/local/etc/redis/redis.conf; \
done

• 创建redis-cluster集群

#关闭防火墙
systemctl stop firewalld
#开机关闭防火墙
sytemctl disable firewalld
docker exec -it redis-8010 bash
#进入容器
cd /usr/local/bin/
# 出现选择提示信息，输入yes
redis-cli --cluster create 192.168.37.128:8010 192.168.37.128:8011 192.168.37.128:8012 192.168.37.128:8013 192.168.37.128:8014 192.168.37.128:8015 --cluster-replicas 1

• 连接redis
  终端连接：

redis-cli -c -h 192.168.37.128 -p 8010
#查看集群状态
info replication
cluster info

redis desktop manager工具连接：

三、springboot使用redis-cluster

application.properties

# database name
spring.redis.database=0
# server host1
#spring.redis.host=47.112.4.110
spring.redis.cluster.nodes=192.168.37.128:8010,192.168.37.128:8011,192.168.37.128:8012,192.168.37.128:8013,192.168.37.128:8014,192.168.37.128:8015
# server password
spring.redis.password=123456
#connection port
# spring.redis.port=6379
# pool settings ...
spring.redis.jedis.pool.max-idle=8 
spring.redis.jedis.pool.min-idle=0
spring.redis.jedis.pool.max-active=8
spring.redis.jedis.pool.max-wait=-1

四、redis-cluster 关机重启后出现异常CLUSTERDOWN The cluster is down

1:S 28 Dec 2019 02:20:21.672 * Connecting to MASTER 192.168.37.128:8012
1:S 28 Dec 2019 02:20:21.672 * MASTER <-> REPLICA sync started
1:S 28 Dec 2019 02:20:24.677 # Error condition on socket for SYNC: No route to host

解决方法：

• 关闭防火墙

# 关闭防火墙
systemctl stop firewalld
# 停止并禁用开机启动
sytemctl disable firewalld

• 开放相应的端口