Dockerfile和Docker网络

Dockerfile

dockerfile 就是用来构建 docker 镜像的命令脚本。

构建步骤：

1、编写 dockerfile 文件

2、docker build 构建成为一个镜像

3、docker run 运行镜像

4、docker push 发布镜像（发布到 DockerHub 或者 阿里云镜像仓库）

一个简单的案例：

# 在/home 中创建目录
mkdir docker-test-volume

# 创建并编辑dockerFile文件 dockerfile1
vim dockerfile1
# 文件内容：（指令大写）
FROM centos
VOLUME ["volume01","volume02"]
CMD echo "----end----"
CMD /bin/bash

# 构建成为一个镜像，不要忘记最后的 . 号
[root@192 docker-test-volume]# docker build -f /home/docker-test-volume/dockerfile1 -t tianyi/centos:1.0 .
Sending build context to Docker daemon  2.048kB
Step 1/4 : FROM centos
 ---> 5d0da3dc9764
Step 2/4 : VOLUME ["volume01","volume02"]
 ---> Running in b7cc7f55e42b
Removing intermediate container b7cc7f55e42b
 ---> 621b250a0261
Step 3/4 : CMD echo "----end----"
 ---> Running in 1c6019c3aa76
Removing intermediate container 1c6019c3aa76
 ---> ecca40110ff7
Step 4/4 : CMD /bin/bash
 ---> Running in d896eb3f826c
Removing intermediate container d896eb3f826c
 ---> 3f4f61425cd8
Successfully built 3f4f61425cd8
Successfully tagged tianyi/centos:1.0

# 运行我们创建的镜像
[root@192 docker-test-volume]# docker run -it tianyi/centos:1.0 /bin/bash

查看我们利用dockerfile创建的镜像，然后运行之后的目录

红框中的这两个目录就是我们生成镜像的时候自动挂载的数据卷目录，这个卷和外部一定有一个同步的目录，查看一下容器详细信息

创建文件，测试已经挂载上。

基础知识：

1. 每个关键字（指令）都必须全部是大写字母
2. 指令从上到下执行
3. # 代表注释
4. 每一个指令都会创建一个新的镜像层，并提交。

dockerfile面相开发，发布项目做镜像（Docker镜像逐渐成为企业交付的标准）就需要编写dockerfile文件

指令

FROM        # 基础镜像，一切从这里开始构建
MAINTAINER  # 镜像作者，姓名+邮箱
RUN         # 镜像构建的时候需要运行的命令
ADD			# 添加的文件
WORKDIR		# 镜像工作的目录
VOLUME		# 挂载的目录
EXPOSE		# 暴露端口配置
CMD			# 指定这个容器启动的时候要运行的命令，例如 cmd echo 来输出一些东西
ENTRYPOINT	# 指定要运行的命令，和cmd类似，但又有不同
COPY		# 类似ADD，将我们文件拷贝到镜像中
ENV			# 构建的时候，设置环境变量

CMD和ENTRYPOINT的区别：

# dockfile 中有这么一行命令
CMD ["ls","-a"]
# build之后成为镜像，在run镜像的时候就会执行ls -a
# 但是却不能追加命令，而且只会执行最后一个命令，例如：
docker run -it 镜像id -l
# 这时候就直接会执行-l，会把我们的ls -a直接覆盖
# 而没有达到我们想要的ls -al这种追加的效果
# 想要达到追加的效果，把我们的CMD替换成 ENTRYPOINT 即可
ENTRYPOINT ["ls","-a"]

案例

# 构建一个centOS的镜像
# 1、编写dockerfile文件——mydockerfile-centos
[root@192 dockerfile]# cat mydockerfile-centos 
#以centos为基础进行编写
FROM centos
#作者信息
MAINTAINER tianyi<cf007110@126.com>
#编写了一个环境变量MYPATH
ENV MYPATH /usr/local
#将工作目录设置为了我们设置的这个环境变量
WORKDIR $MYPATH
#安装vim命令和ip相关命令（例如ifconfig）
RUN yum -y install vim
RUN yum -y install net-tools
#开启80端口的映射
EXPOSE 80
#输出一些信息
CMD echo $MYPATH
CMD echo "----end----"
#打开一个交互式shell
CMD /bin/bash

# 2、docker build 命令来构建镜像
#参数
#-f 要构建的 dockerfile 文件
#-t 构建target，要构建成的镜像名称
[root@192 dockerfile]# docker build -f mydockerfile-centos -t mycentos:0.1 .
#如果yum下载vim的时候有以下报错，就替换命令为：RUN rpm -qa|grep vim
Error: Failed to download metadata for repo 'appstream': Cannot prepare internal mirrorlist: No URLs in mirrorlist

docker history 查看镜像dockerfile构建过程：

[root@192 dockerfile]# docker history mysql:5.7
IMAGE          CREATED        CREATED BY                                      SIZE      COMMENT
c20987f18b13   3 months ago   /bin/sh -c #(nop)  CMD ["mysqld"]               0B        
<missing>      3 months ago   /bin/sh -c #(nop)  EXPOSE 3306 33060            0B        
<missing>      3 months ago   /bin/sh -c #(nop)  ENTRYPOINT ["docker-entry…   0B        
<missing>      3 months ago   /bin/sh -c ln -s usr/local/bin/docker-entryp…   34B       
<missing>      3 months ago   /bin/sh -c #(nop) COPY file:345a22fe55d3e678…   14.5kB    
<missing>      3 months ago   /bin/sh -c #(nop)  VOLUME [/var/lib/mysql]      0B        
<missing>      3 months ago   /bin/sh -c {   echo mysql-community-server m…   313MB     
<missing>      3 months ago   /bin/sh -c echo 'deb http://repo.mysql.com/a…   55B       
<missing>      3 months ago   /bin/sh -c #(nop)  ENV MYSQL_VERSION=5.7.36-…   0B        
<missing>      3 months ago   /bin/sh -c #(nop)  ENV MYSQL_MAJOR=5.7          0B        
<missing>      3 months ago   /bin/sh -c set -ex;  key='A4A9406876FCBD3C45…   1.84kB    
<missing>      3 months ago   /bin/sh -c apt-get update && apt-get install…   52.2MB    
<missing>      3 months ago   /bin/sh -c mkdir /docker-entrypoint-initdb.d    0B        
<missing>      3 months ago   /bin/sh -c set -eux;  savedAptMark="$(apt-ma…   4.17MB    
<missing>      3 months ago   /bin/sh -c #(nop)  ENV GOSU_VERSION=1.12        0B        
<missing>      3 months ago   /bin/sh -c apt-get update && apt-get install…   9.34MB    
<missing>      3 months ago   /bin/sh -c groupadd -r mysql && useradd -r -…   329kB     
<missing>      3 months ago   /bin/sh -c #(nop)  CMD ["bash"]                 0B        
<missing>      3 months ago   /bin/sh -c #(nop) ADD file:bd5c9e0e0145fe33b…   69.3MB    
[root@192 dockerfile]# 

制作Tomcat镜像

1、准备镜像文件
jdk压缩包和tomcat的压缩包

2、编写 dockerfile 文件
官方命名Dockerfile，build的时候会自动寻找这个文件，就不用-f去指定了

[root@192 tomcat]# cat Dockerfile 
FROM centos
MAINTAINER tianyi<3055921405@qq.com>

COPY readme.txt /user/local/readme.txt

ADD apache-tomcat-9.0.60.tar.gz /usr/local/
ADD jdk-8u202-linux-x64.tar.gz /usr/local/

# 非必要，安装vim命令
RUN rpm -qa|grep vim

ENV MYPATH /usr/local
WORKDIR $MYPATH

ENV JAVA_HOME /usr/local/jdk1.8.0_202
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.60
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/bin

# 开启容器8080端口的映射，不要改成其他端口，将会导致到时候部署的访问不到tomcat
EXPOSE 8080

CMD ["/usr/local/apache-tomcat-9.0.60/bin/catalina.sh","run"]

3、构建镜像

# 没有指定版本，默认就是latest（最新）的
[root@192 tomcat]# docker build -t mytomcat .

这时候就可以看到我们的镜像了：

4、启动镜像

# 开启端口映射，挂载项目目录和日志目录两个卷
[root@192 tomcat]# docker run -d -p 9090:8080 --name dockfiletomcat -v /home/dockerfile/tomcat/webapps/test:/usr/local/apache-tomcat-9.0.60/webapps/test -v /home/dockerfile/tomcat/webapps/logs:/usr/local/apache-tomcat-9.0.60/logs mytomcat

# 如果我们要部署两个tomcat，那么我们可以运行两遍这个镜像（这里我们就不挂载卷了，注意看端口的映射，防止端口冲突防止的是宿主机端口的冲突，运行的时候改变容器映射到宿主机的端口就可，容器和容器之间的端口并不会冲突，tomcat容器的端口就是8080，dockerfile中开启映射的端口就是8080）
[root@192 tomcat]# docker run -d -p 9091:8080 --name dockfiletomcat02 mytomcat

# 查看运行的容器
[root@192 tomcat]# docker ps
CONTAINER ID   IMAGE      COMMAND                  CREATED              STATUS              PORTS                                       NAMES
c6845b6c49f2   mytomcat   "/usr/local/apache-t…"   4 seconds ago        Up 3 seconds        0.0.0.0:9091->8080/tcp, :::9091->8080/tcp   dockfiletomcat02
cdfd7ebc2593   mytomcat   "/usr/local/apache-t…"   About a minute ago   Up About a minute   0.0.0.0:9090->8080/tcp, :::9090->8080/tcp   dockfiletomcat

# 浏览器访问或者直接使用curl命令来测试（有内容就表示成功了）
[root@192 tomcat]# curl localhost:9090
[root@192 tomcat]# curl localhost:9091

5、部署项目测试
依靠卷的功能，我们来部署一个试试

因为之前的挂载，我们就直接在服务器外部目录
/home/dockerfile/tomcat/webapps/test中，创建index.html文件

[root@192 test]# cat index.html
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Hello Docker!</title>
</head>
<body>
	<h1>dockerfile 部署tomcat</h1>
	<image src="https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fnimg.ws.126.net%2F%3Furl%3Dhttp%253A%252F%252Fdingyue.ws.126.net%252F2022%252F0302%252Fb6fe877fj00r83z4q001tc000hs012hg.jpg%26thumbnail%3D660x2147483647%26quality%3D80%26type%3Djpg&refer=http%3A%2F%2Fnimg.ws.126.net&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=auto?sec=1650971521&t=0c9b6c93b11e89d03a118c97c45c3324"></image>
</body>
</html>

然后访问测 http://192.168.1.7:9090/test/

看到页面内容，我们的部署测试就算成功了

附：关于端口映射，可以看看这个博客：https://blog.csdn.net/annita2019/article/details/108680031

发布镜像

一：发布镜像到 dockerHub
略…

二：发布镜像到

阿里云容器镜像服务

1、点击进入我们创建的个人实例中

2、创建命名空间和镜像仓库

3、点击进入我们镜像仓库
操作方法这里都有了

就可以开始我们的操作，提交到阿里云镜像服务中了

1. 登录阿里云Docker Registry

$ docker login --username=自挂东坡枝 registry.cn-hangzhou.aliyuncs.com

用于登录的用户名为阿里云账号全名，密码为开通服务时设置的密码。

您可以在访问凭证页面修改凭证密码。

2. 从Registry中拉取镜像

$ docker pull registry.cn-hangzhou.aliyuncs.com/haodetianyi/docker_study:[镜像版本号]

3. 将镜像推送到Registry
   命令中 docker_study 就是我们的仓库名称，填写什么仓库名称，就会提交到哪个仓库中，没有的话就会自己创建

$ docker login --username=自挂东坡枝 registry.cn-hangzhou.aliyuncs.com
$ docker tag [ImageId] registry.cn-hangzhou.aliyuncs.com/haodetianyi/docker_study:[镜像版本号]
$ docker push registry.cn-hangzhou.aliyuncs.com/haodetianyi/docker_study:[镜像版本号]

请根据实际镜像信息替换示例中的[ImageId]和[镜像版本号]参数。

4. 选择合适的镜像仓库地址

从ECS推送镜像时，可以选择使用镜像仓库内网地址。推送速度将得到提升并且将不会损耗您的公网流量。

如果您使用的机器位于VPC网络，请使用 registry-vpc.cn-hangzhou.aliyuncs.com 作为Registry的域名登录。

5. 示例

使用"docker tag"命令重命名镜像，并将它通过专有网络地址推送至Registry。

$ docker imagesREPOSITORY                                                         TAG                 IMAGE ID            CREATED             VIRTUAL SIZEregistry.aliyuncs.com/acs/agent                                    0.7-dfb6816         37bb9c63c8b2        7 days ago          37.89 MB$ docker tag 37bb9c63c8b2 registry-vpc.cn-hangzhou.aliyuncs.com/acs/agent:0.7-dfb6816

使用 “docker push” 命令将该镜像推送至远程。

$ docker push registry-vpc.cn-hangzhou.aliyuncs.com/acs/agent:0.7-dfb6816

Docker网络

测试：

# 查看 linux 宿主机的ip
# lo 为本机回环地址，代表设备的本地虚拟接口
# ens33 网卡地址
# eth0 阿里云内网地址，我们这是虚拟机，所以没有这个地址
# docker0 docker0 地址
[root@192 admin]# 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:0c:29:d1:34:9d brd ff:ff:ff:ff:ff:ff
    inet 192.168.1.7/24 brd 192.168.1.255 scope global noprefixroute dynamic ens33
       valid_lft 255209sec preferred_lft 255209sec
    inet6 2408:820c:8f4e:27d0:446d:27b2:1c3f:4771/64 scope global noprefixroute dynamic 
       valid_lft 193690sec preferred_lft 107290sec
    inet6 fe80::56b:f8cb:7c0b:ad9d/64 scope link noprefixroute 
       valid_lft forever preferred_lft forever
3: virbr0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN group default qlen 1000
    link/ether 52:54:00:fc:08:60 brd ff:ff:ff:ff:ff:ff
    inet 192.168.122.1/24 brd 192.168.122.255 scope global virbr0
       valid_lft forever preferred_lft forever
4: virbr0-nic: <BROADCAST,MULTICAST> mtu 1500 qdisc pfifo_fast master virbr0 state DOWN group default qlen 1000
    link/ether 52:54:00:fc:08:60 brd ff:ff:ff:ff:ff:ff
5: docker0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:37:62:0c:57 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:37ff:fe62:c57/64 scope link 
       valid_lft forever preferred_lft forever
# 启动容器后，再在宿主机中查看ip，就会发现多出了这段信息
7: veth0a292a8@if6: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue master docker0 state UP group default 
    link/ether be:1b:d4:73:2a:15 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet6 fe80::bc1b:d4ff:fe73:2a15/64 scope link 
       valid_lft forever preferred_lft forever

# 我们再起一个docker容器，然后进入容器内部，查看容器的ip
[root@cdfd7ebc2593 local]# 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
6: eth0@if7: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
       valid_lft forever preferred_lft forever

原理：我们安装了docker，就会有一个网卡docker0，使用的技术就是 veth-pair 技术（桥接）。

我们每起一个docker容器，docker就会给docker容器分配一个ip

再启动一个docker容器，我们ip addr再查看容器内部和宿主机，发现又多出一对网卡，例如上面的7: veth0a292a8@if6:
这就是 veth-pair 技术，它都是成对出现的。一端连着协议栈，一端彼此相连着。用于连接各种虚拟网络设备，docker中所有的网络接口都是虚拟的。

所以：
宿主机可以ping通docker容器
通过 link 容器互联（使用较少这里就略了）命令，docker容器可以ping通同一宿主机的其他docker容器

容器互联

查看所有的 docker 网络

[root@192 admin]# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
15148edbf2c3   bridge    bridge    local
507478d9d3f2   host      host      local
797478075cd9   none      null      local

1. Host模式：与宿主机在同一个网络中，但没有独立IP地址。
2. None模式：该模式将容器放置在它自己的网络栈中，但是并不进行任何配置。实际上，该模式关闭了容器的网络功能，在以下两种情况下是有用的：容器并不需要网络（例如只需要写磁盘卷的批处理任务）
3. Bridge模式（默认）：桥接模式，容器使用独立network Namespace，并连接到docker0虚拟网卡（默认模式）。通过docker0网桥以及Iptables nat表配置与宿主机通信；bridge模式是Docker默认的网络设置，此模式会为每一个容器分配Network Namespace、设置IP等，并将一个主机上的Docker容器连接到一个虚拟网桥上。

自定义网络：

# 我们在运行镜像的时候，没有指定 --net 的参数信息，默认是有一个 --net bridge，而这个docker0
docker run -d -P --name tomcat01 tomcat
# 上面这个就等效于下面这个
docker run -d -P --name tomcat01 --net bridge tomcat

# docker0特点，默认，域名不能访问，容器间通过--link可以打通连接

我们可以自定义一个网络（能于外界进行网络通信）：

# 查看docker网络创建命令docker network create的参数信息
[root@192 admin]# docker network create --help

Usage:  docker network create [OPTIONS] NETWORK

Create a network

Options:
      --attachable           Enable manual container attachment
      --aux-address map      Auxiliary IPv4 or IPv6 addresses used by Network driver (default map[])
      --config-from string   The network from which to copy the configuration
      --config-only          Create a configuration only network
  -d, --driver string        Driver to manage the Network (default "bridge")
      --gateway strings      IPv4 or IPv6 Gateway for the master subnet
      --ingress              Create swarm routing-mesh network
      --internal             Restrict external access to the network
      --ip-range strings     Allocate container ip from a sub-range
      --ipam-driver string   IP Address Management Driver (default "default")
      --ipam-opt map         Set IPAM driver specific options (default map[])
      --ipv6                 Enable IPv6 networking
      --label list           Set metadata on a network
  -o, --opt map              Set driver specific options (default map[])
      --scope string         Control the network's scope
      --subnet strings       Subnet in CIDR format that represents a network segment

# 子网掩码：为了解决公网IP地址不足的情况，于是发明了私有IP （Private IP），比如一个家庭（公司）有几台电脑，每台电脑都拥有 私有IP，它们之间组成一个局域网，也就是说，一个公有IP，可以分出很多个很多个私有IP，这样IPV4不足的问题就解决了
# 创建docker自定义网络,名为mynet
# --driver bridge 是默认值
# --gateway 192.168.0.1 也不是必须的
[root@192 admin]# docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
# 查看自定义网络
NETWORK ID     NAME      DRIVER    SCOPE
15148edbf2c3   bridge    bridge    local
507478d9d3f2   host      host      local
3ef81243a4d8   mynet     bridge    local
797478075cd9   none      null      local

查看我们自定义的网络：

# 在自定义网络中启动容器
[root@192 admin]# docker run -it -P --name tomcat-net-01 --net mynet mytomcat bash
[root@192 admin]# docker run -it -P --name tomcat-net-02 --net mynet mytomcat bash

这时候查看mynet的信息，就可以看到多了两个容器

这时候在tomcat-net-01中测试ping tomcat-net-02，发现可以ping通

[root@192 admin]# docker exec -d tomcat-net-02 bash & ping 192.168.0.3
# 也可以通过容器名字进行联通
[root@192 admin]# docker exec -it tomcat-net-01 ping tomcat-net-02
PING tomcat-net-02 (192.168.0.3) 56(84) bytes of data.
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=1 ttl=64 time=0.557 ms
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=2 ttl=64 time=0.051 ms
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=3 ttl=64 time=0.051 ms
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=4 ttl=64 time=0.052 ms

网络联通

两个网络之间进行通信：

# 连接一个容器到一个网络
docker network connect

# 先在docker0中也起两个tomcat容器
# 效果：
[root@192 admin]# docker ps
CONTAINER ID   IMAGE      COMMAND                  CREATED       STATUS          PORTS                                         NAMES
88c2b3c09077   mytomcat   "bash"                   2 hours ago   Up 2 hours      0.0.0.0:49161->8080/tcp, :::49161->8080/tcp   tomcat-net-02
05d7ef93893a   mytomcat   "bash"                   2 hours ago   Up 2 hours      0.0.0.0:49160->8080/tcp, :::49160->8080/tcp   tomcat-net-01
c6845b6c49f2   mytomcat   "/usr/local/apache-t…"   6 days ago    Up 3 seconds    0.0.0.0:9091->8080/tcp, :::9091->8080/tcp     dockfiletomcat02
cdfd7ebc2593   mytomcat   "/usr/local/apache-t…"   6 days ago    Up 10 seconds   0.0.0.0:9090->8080/tcp, :::9090->8080/tcp     dockfiletomcat
# 测试打通 dockfiletomcat 到 mynet 网络中
[root@192 admin]# docker network connect mynet dockfiletomcat

# 再查看 mynet 的信息，发现就将容器 dockfiletomcat 添加到网络 mynet 中了
# 就导致dockfiletomcat这一个容器，两个ip
[root@192 admin]# docker network inspect mynet

# 测试：容器 dockfiletomcat 就可以ping通目标我们自定义的网络下的任一容器了
[root@192 admin]# docker exec -it dockfiletomcat ping tomcat-net-01
PING tomcat-net-01 (192.168.0.2) 56(84) bytes of data.
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=1 ttl=64 time=0.138 ms
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=2 ttl=64 time=0.053 ms
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=3 ttl=64 time=0.054 ms

实战：部署Redis集群

#1、创建网卡
docker network create redis --subnet 172.38.0.0/16

#2、通过脚本创建留个redis配置，直接复制回车运行
# 如果要连接外部集群，cluster-announce-ip的值就要换成宿主机ip
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
port 6379
bind 0.0.0.0
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-announce-ip 172.38.0.1${port}
cluster-announce-port 6379
cluster-announce-bus-port 16379
appendonly yes
EOF
done

#3、运行容器，也可以直接粘贴在脚本中执行
docker run -p 6371:6379 -p 16371:16379 --name redis-1 \
-v /mydata/redis/node-1/data:/data \
-v /mydata/redis/node-1/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.11 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
# 手动启动的话就稍作修改，然后再运行，脚本更方便...
docker run -p 6376:6379 -p 16376:16379 --name redis-6 \
-v /mydata/redis/node-6/data:/data \
-v /mydata/redis/node-6/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.16 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
# 把我们创建的留个redis都启动起来……

#4、创建集群
# 随便进入一个容器
docker exec -it redis-1 sh
# 然后创建redis切片集群
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

然后得到的集群配置（3master和3slave）：

# 创建集群命令的执行效果：
>>> Performing hash slots allocation on 6 nodes...
Master[0] -> Slots 0 - 5460
Master[1] -> Slots 5461 - 10922
Master[2] -> Slots 10923 - 16383
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: 57f9b4e71ab7c52ef56194c2eb0fd1f110a79d4b 172.38.0.11:6379
   slots:[0-5460] (5461 slots) master
M: 2419420287d949714af05ccc72bd3055031c2ba1 172.38.0.12:6379
   slots:[5461-10922] (5462 slots) master
M: 40bb8deacd5ec4b8e51a9279b23467acc7434670 172.38.0.13:6379
   slots:[10923-16383] (5461 slots) master
S: adf3609a6f687ea92bb74332fc25803a045a7c38 172.38.0.14:6379
   replicates 40bb8deacd5ec4b8e51a9279b23467acc7434670
S: b256e28a8571f0c464e1c36e019ca20b1ad2e2e9 172.38.0.15:6379
   replicates 57f9b4e71ab7c52ef56194c2eb0fd1f110a79d4b
S: 9e6fc9e25c3cee15de5d17585c1037143e8e1c27 172.38.0.16:6379
   replicates 2419420287d949714af05ccc72bd3055031c2ba1
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
..
>>> Performing Cluster Check (using node 172.38.0.11:6379)
M: 57f9b4e71ab7c52ef56194c2eb0fd1f110a79d4b 172.38.0.11:6379
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
S: 9e6fc9e25c3cee15de5d17585c1037143e8e1c27 172.38.0.16:6379
   slots: (0 slots) slave
   replicates 2419420287d949714af05ccc72bd3055031c2ba1
M: 40bb8deacd5ec4b8e51a9279b23467acc7434670 172.38.0.13:6379
   slots:[10923-16383] (5461 slots) master
   1 additional replica(s)
S: b256e28a8571f0c464e1c36e019ca20b1ad2e2e9 172.38.0.15:6379
   slots: (0 slots) slave
   replicates 57f9b4e71ab7c52ef56194c2eb0fd1f110a79d4b
M: 2419420287d949714af05ccc72bd3055031c2ba1 172.38.0.12:6379
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
S: adf3609a6f687ea92bb74332fc25803a045a7c38 172.38.0.14:6379
   slots: (0 slots) slave
   replicates 40bb8deacd5ec4b8e51a9279b23467acc7434670
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.

# 连接redis集群
/data # redis-cli -c

# 查看集群信息
127.0.0.1:6379> cluster info
cluster_state:ok
cluster_slots_assigned:16384
cluster_slots_ok:16384
cluster_slots_pfail:0
cluster_slots_fail:0
cluster_known_nodes:6
# 集群数量，三对1主1从
cluster_size:3
cluster_current_epoch:6
cluster_my_epoch:1
cluster_stats_messages_ping_sent:519
cluster_stats_messages_pong_sent:514
cluster_stats_messages_sent:1033
cluster_stats_messages_ping_received:509
cluster_stats_messages_pong_received:519
cluster_stats_messages_meet_received:5
cluster_stats_messages_received:1033

# 查看集群节点信息，一共6个节点
127.0.0.1:6379> cluster nodes
9e6fc9e25c3cee15de5d17585c1037143e8e1c27 172.38.0.16:6379@16379 slave 2419420287d949714af05ccc72bd3055031c2ba1 0 1649010125508 6 connected
40bb8deacd5ec4b8e51a9279b23467acc7434670 172.38.0.13:6379@16379 master - 0 1649010124002 3 connected 10923-16383
b256e28a8571f0c464e1c36e019ca20b1ad2e2e9 172.38.0.15:6379@16379 slave 57f9b4e71ab7c52ef56194c2eb0fd1f110a79d4b 0 1649010124103 5 connected
57f9b4e71ab7c52ef56194c2eb0fd1f110a79d4b 172.38.0.11:6379@16379 myself,master - 0 1649010124000 1 connected 0-5460
2419420287d949714af05ccc72bd3055031c2ba1 172.38.0.12:6379@16379 master - 0 1649010123496 2 connected 5461-10922
adf3609a6f687ea92bb74332fc25803a045a7c38 172.38.0.14:6379@16379 slave 40bb8deacd5ec4b8e51a9279b23467acc7434670 0 1649010124504 4 connected

# 测试：存储一个值，发现默认存储到了redis-3中
127.0.0.1:6379> set a b
-> Redirected to slot [15495] located at 172.38.0.13:6379
OK
172.38.0.13:6379> get a
"b"
# 这时候停止掉redis-3，再查看redis集群信息，发现从机redis-4顶替了redis3成为了主机
127.0.0.1:6379> cluster nodes
2419420287d949714af05ccc72bd3055031c2ba1 172.38.0.12:6379@16379 master - 0 1649012837869 2 connected 5461-10922
9e6fc9e25c3cee15de5d17585c1037143e8e1c27 172.38.0.16:6379@16379 slave 2419420287d949714af05ccc72bd3055031c2ba1 0 1649012837000 6 connected
40bb8deacd5ec4b8e51a9279b23467acc7434670 172.38.0.13:6379@16379 slave,fail adf3609a6f687ea92bb74332fc25803a045a7c38 1649012795467 1649012793651 7 connected
57f9b4e71ab7c52ef56194c2eb0fd1f110a79d4b 172.38.0.11:6379@16379 master - 0 1649012836867 1 connected 0-5460
adf3609a6f687ea92bb74332fc25803a045a7c38 172.38.0.14:6379@16379 myself,master - 0 1649012836000 7 connected 10923-16383
b256e28a8571f0c464e1c36e019ca20b1ad2e2e9 172.38.0.15:6379@16379 slave 57f9b4e71ab7c52ef56194c2eb0fd1f110a79d4b 0 1649012836565 5 connected
# 再次取值，还是可以取到的
127.0.0.1:6379> get a
"b"

附：使用可视化软件连接redis的时候，只可以选择DB0

SpringCloud微服务打包镜像

1、idea安装插件（基于idea的打包）
作用：连接服务器，编写dockerfile的时候高亮提示

2、使用maven的package命令打包程序
到jar包所在目录，打开cmd窗口，java -jar jar包文件名 来执行测试一下，可以运行就表示ok

3、编写Dockerfile

FROM java:8

# 然后这个文件夹中不会有这个复制后的文件，只是暂存使用
COPY *.jar /app.jar

# 甚至不用指定开放端口，application配置文件中配置的端口就够了
ENTRYPOINT ["java","-jar","/app.jar"]

4、利用Xftp将 jar 包和 Dockerfile 文件拷贝到服务器中

5、通过Dockerfile构建镜像

# 确保已经添加进来，并且处于Dockerfile所在目录中
[root@192 springcloudstudy]# ll
total 46312
-rw-r--r--. 1 root root      120 Apr  4 05:01 Dockerfile
-rw-r--r--. 1 root root 47416981 Apr  4 05:00 eureka-server-1.0-SNAPSHOT.jar
[root@192 springcloudstudy]# docker build -t eureka-service-01 .
# 接下来等待构建完成
# 就可以查看到构建好的容器了
[root@192 springcloudstudy]# docker images
REPOSITORY                                               TAG                IMAGE ID       CREATED         SIZE
eureka-service-01                                        latest             b39a7a730ae9   4 minutes ago   691MB

6、启动容器测试

启动容器（端口映射的时候，直接映射出springboot项目配置文件指定的端口就可）：

测试：

7、然后就可以利用docker push命令发布了，交付给他人，他人就只用pull拉取镜像直接启动就ok