docker学自b站的遇见狂神说 ，感谢老师！
容器数据卷 什么是容器数据卷 docker的理念回顾
将应用和环境打包成一个镜像！
数据？如果数据都在容器中，那么我们容器删除，数据就会丢失！需求：数据可以持久化
MySQL，容器删除了，删库跑路！需求：MySQL数据可以存储在本地！
容器之间可以有一个数据共享的技术！Docker容器中产生的数据，同步到本地！
这就是卷技术！目录的挂载，将我们容器内的目录，挂载到Linux上面！
总结一句话：容器的持久化和同步操作！容器间也是可以数据共享的！
使用数据卷
方式一 ：直接使用命令挂载 -v
1 2 3 4 5 6 7 -v, --volume list Bind mount a volume docker run -it -v 主机目录:容器内目录 -p 主机端口:容器内端口 # 测试 ➜ ~ docker run -it -v /home/ceshi:/home centos /bin/bash # 启动起来,可以通过 docker inspect 容器id 查看
测试文件的同步
再来测试！
停止容器
宿主机修改文件
启动容器
容器内的数据依旧是同步的
好处：我们以后修改只需要在本地修改即可，容器内会自动同步！
实战：安装MySQL 思考：MySQL的数据持久化的问题
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 # 获取mysql镜像 ➜ ~ docker pull mysql:5.7 # 运行容器,需要做数据挂载 # 参考官网hub docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag # 启动我们得 -d 后台运行 -p 端口映射 -v 卷挂载 -e 环境配置 -- name 容器名字 ➜ ~ docker run -d -p 3306:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7 # 启动成功之后，我们在本地使用sqlyog来测试一下 # sqlyog-连接到服务器的3306--和容器内的3306映射 # 在本地测试创建一个数据库，查看一下我们映射的路径是否ok！
假设我们将容器删除
发现，我们挂载到本地的数据卷依旧没有丢失，这就实现了容器数据持久化功能。
具名和匿名挂载 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 # 匿名挂载 -v 容器内路径! docker run -d -P --name nginx01 -v /etc/nginx nginx # 查看所有的volume的情况 ➜ ~ docker volume ls DRIVER VOLUME NAME local 33ae588fae6d34f511a769948f0d3d123c9d45c442ac7728cb85599c2657e50d local # 这里发现，这种就是匿名挂载，我们在 -v只写了容器内的路径，没有写容器外的路劲！ # 具名挂载 ➜ ~ docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx ➜ ~ docker volume ls DRIVER VOLUME NAME local juming-nginx # 通过 -v 卷名：容器内路径 # 查看一下这个卷
所有的docker容器内的卷，没有指定目录的情况下都是在/var/lib/docker/volumes/xxxx/_data具名挂载
1 2 3 4 # 如何确定是具名挂载、匿名挂载、还是指定路径挂载！ -v 容器内路径 #匿名挂载 -v 卷名：容器内路径 #具名挂载 -v /宿主机路径：容器内路径 #指定路径挂载 docker volume ls 是查看不到的
拓展：
1 2 3 4 5 6 7 # 通过 -v 容器内路径： ro rw 改变读写权限 ro #readonly 只读 rw #readwrite 可读可写 docker run -d -P --name nginx05 -v juming:/etc/nginx:ro nginx docker run -d -P --name nginx05 -v juming:/etc/nginx:rw nginx # ro 只要看到ro就说明这个路径只能通过宿主机来操作，容器内部是无法操作！
初识Dockerfile Dockerfile 就是用来构建docker镜像的构建文件！命令脚本！先体验一下！
通过这个脚本可以生成镜像，镜像是一层一层的，脚本是一个一个的命令，每个命令都是一层！
1 2 3 4 5 6 7 8 9 # 创建一个dockerfile文件，名字可以随便 建议Dockerfile # 文件中的内容 指令(大写) 参数 FROM centos VOLUME ["volume01","volume02"] CMD echo "----end----" CMD /bin/bash # 这里的每个命令，就是镜像的一层！
启动自己写的镜像
这个卷和外部一定有一个同步的目录
查看一下卷挂载
docker inspect 容器id
测试一下刚才的文件是否同步出去了！
这种方式使用的十分多，因为我们通常会构建自己的镜像！
假设构建镜像时候没有挂载卷，要手动镜像挂载 -v 卷名：容器内路径！
数据卷容器 多个MySQL同步数据！
命名的容器挂载数据卷！
启动3个容器,通过我们刚才自己写的镜像启动
1 2 # 测试：可以删除docker01，查看一下docker02和docker03是否可以访问这个文件 # 测试依旧可以访问
多个mysql实现数据共享
1 2 3 ➜ ~ docker run -d -p 3306:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7 ➜ ~ docker run -d -p 3307:3306 -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 --volumes-from mysql01 mysql:5.7 # 这个时候，可以实现两个容器数据同步！
结论：
容器之间的配置信息的传递，数据卷容器的生命周期一直持续到没有容器使用为止。
但是一旦你持久化到了本地，这个时候，本地的数据是不会删除的！
DockerFile DockerFile介绍 dockerfile 是用来构建docker镜像的文件！命令参数脚本！
构建步骤：
编写一个dockerfile文件
docker build 构建称为一个镜像
docker run运行镜像
docker push发布镜像（DockerHub 、阿里云仓库)
查看一下官方是怎么做的?
点击后跳到一个Dockerfile
很多官方镜像都是基础包，很多功能没有，我们通常会自己搭建自己的镜像！
官方既然可以制作镜像，那我们也可以！
DockerFile构建过程 基础知识：
每个保留关键字(指令）都是必须是大写字母
执行从上到下顺序
#表示注释
每一个指令都会创建提交一个新的镜像曾，并提交！
Dockerfile是面向开发的，我们以后要发布项目，做镜像，就需要编写dockerfile文件，这个文件十分简单！
Docker镜像逐渐成企业交付的标准，必须要掌握！
步骤：开发,部署,运维…缺一不可!
DockerFile：构建文件，定义了一切的步骤，源代码
DockerImages：通过DockerFile构建生成的镜像，最终发布和运行产品。
Docker容器：容器就是镜像运行起来提供服务。
DockerFile的指令
指令
描述
FROM
# 基础镜像，一切从这里开始构建
MAINTAINER
# 镜像是谁写的， 姓名+邮箱
RUN
# 镜像构建的时候需要运行的命令
ADD
# 步骤，tomcat镜像，这个tomcat压缩包！添加内容 添加同目录
WORKDIR
# 镜像的工作目录
VOLUME
# 挂载的目录
EXPOSE
# 保留端口配置
CMD
# 指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代。
ENTRYPOINT
# 指定这个容器启动的时候要运行的命令，可以追加命令
ONBUILD
# 当构建一个被继承 DockerFile 这个时候就会运行ONBUILD的指令，触发指令。
COPY
# 类似ADD，将我们文件拷贝到镜像中
ENV
# 构建的时候设置环境变量！
以前的话我们就是使用别人的,现在我们知道了这些指令后,我们来练习自己写一个镜像!
实战测试 Docker Hub 中 99% 镜像都是从这个基础镜像过来的 FROM scratch ,然后配置需要的软件和配置来进行的构建
创建一个自己的centos
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 # 1.编写Dockerfile文件 vim mydockerfile-centos FROM centos MAINTAINER cheng<1204598429@qq.com> ENV MYPATH /usr/local WORKDIR $MYPATH RUN yum -y install vim RUN yum -y install net-tools EXPOSE 80 CMD echo $MYPATH CMD echo "-----end----" CMD /bin/bash
1 2 3 # 2、通过这个文件构建镜像 # 命令 docker build -f 文件路径 -t 镜像名:[tag] . docker build -f mydockerfile-centos -t mycentos:0.1 .
对比：之前原生的centos
我们增加之后的镜像
我们可以列出本地进行的变更历史
docker history 镜像id
我们平时拿到一个镜像，可以研究一下是什么做的
CMD 和 ENTRYPOINT区别
1 2 CMD # 指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代。 ENTRYPOINT # 指定这个容器启动的时候要运行的命令，可以追加命令
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 # 编写 dockerfile 文件 [root@iZ70q42pccuzt0Z dockerfile]# vim dockerfile-cmd-test FROM centos CMD ["ls","-a"] # 构建镜像 [root@iZ70q42pccuzt0Z dockerfile]# docker build -f dockerfile-cmd-test -t cmdtest . Sending build context to Docker daemon 3.072kB Step 1/2 : FROM centos ---> 831691599b88 Step 2/2 : CMD ["ls","-a"] ---> Running in 98add508110f Removing intermediate container 98add508110f ---> 80ecc2c72ef0 Successfully built 80ecc2c72ef0 Successfully tagged cmdtest:latest # run 运行,发现ls -a命令生效 [root@iZ70q42pccuzt0Z dockerfile]# docker run 80ecc2c72ef0 . .. .dockerenv bin dev etc home lib lib64 .... # 想追加一个命令 -l => ls -al [root@iZ70q42pccuzt0Z dockerfile]# docker run 80ecc2c72ef0 -l docker: Error response from daemon: OCI runtime create failed: container_linux.go:349: starting container process caused "exec: \"-l\": executable file not found in $PATH": unknown. [root@iZ70q42pccuzt0Z dockerfile]# # cmd的情况下 -l 替换了 CMD ["ls" ,"-a" ] 命令,-l 不是命令所以报错!
ENTRYPOINT测试
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 [root@iZ70q42pccuzt0Z dockerfile]# vim dockerfile-cmd-entrypoint FROM centos ENTRYPOINT ["ls","-a"] [root@iZ70q42pccuzt0Z dockerfile]# docker build -f dockerfile-cmd-entrypoint -t entrypoint-test . Sending build context to Docker daemon 4.096kB Step 1/2 : FROM centos ---> 831691599b88 Step 2/2 : ENTRYPOINT ["ls","-a"] ---> Running in e9703651ca19 Removing intermediate container e9703651ca19 ---> c91e4c9f056b Successfully built c91e4c9f056b Successfully tagged entrypoint-test:latest # 我们的追加命令，是直接拼接在我们的 ENTRYPOINT 命令的后面! [root@iZ70q42pccuzt0Z dockerfile]# docker run c91e4c9f056b -l total 56 drwxr-xr-x 1 root root 4096 Jul 4 13:42 . drwxr-xr-x 1 root root 4096 Jul 4 13:42 .. -rwxr-xr-x 1 root root 0 Jul 4 13:42 .dockerenv lrwxrwxrwx 1 root root 7 May 11 2019 bin -> usr/bin drwxr-xr-x 5 root root 340 Jul 4 13:42 dev drwxr-xr-x 1 root root 4096 Jul 4 13:42 etc drwxr-xr-x 2 root root 4096 May 11 2019 home lrwxrwxrwx 1 root root 7 May 11 2019 lib -> usr/lib .... [root@iZ70q42pccuzt0Z dockerfile]#
Dockerfile中很多命令都十分的相似,我们需要了解它们的区别,我们最好的学习就是对比他们然后测试效果!
实战:Tomcat镜像 1、准备镜像文件tomcat压缩包, jdk的压缩包!
2、编写dockerfile文件,官方命名 Dockerfile ,build会自动寻找这个文件,就不需要 -f 指定了!
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 FROM centos MAINTAINER cheng<1204598429@qq.com> COPY README /usr/local/README #复制文件 ADD jdk-8u231-linux-x64.tar.gz /usr/local/ #复制解压 ADD apache-tomcat-9.0.35.tar.gz /usr/local/ #复制解压 RUN yum -y install vim ENV MYPATH /usr/local #设置环境变量 WORKDIR $MYPATH #设置工作目录 ENV JAVA_HOME /usr/local/jdk1.8.0_231 #设置环境变量 ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.35 #设置环境变量 ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib #设置环境变量 分隔符是： EXPOSE 8080 #设置暴露的端口 CMD /usr/local/apache-tomcat-9.0.35/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.35/logs/catalina.out # 设置默认命令
3、构建镜像
1 2 # 因为dockerfile命名使用默认命名 因此不用使用-f 指定文件 $ docker build -t mytomcat:0.1 .
4、run镜像
1 $ docker run -d -p 8080:8080 --name tomcat01 -v /home/kuangshen/build/tomcat/test :/usr/local /apache-tomcat-9.0.35/webapps/test -v /home/kuangshen/build/tomcat/tomcatlogs/:/usr/local /apache-tomcat-9.0.35/logs mytomcat:0.1
5、访问测试
6、发布项目(由于做了卷挂载，我们直接在本地编写项目就可以发布了！)
发现：项目部署成功，可以直接访问！
我们以后开发的步骤：需要掌握Dockerfile的编写！我们之后的一切都是使用docker镜像来发布运行！
发布自己的镜像
Dockerhub
1、地址 https://hub.docker.com/
2、确定这个账号可以登录
3、登录
1 2 3 4 5 6 7 8 9 10 $ docker login --help Usage: docker login [OPTIONS] [SERVER] Log in to a Docker registry. If no server is specified, the default is defined by the daemon. Options: -p, --password string Password --password-stdin Take the password from stdin -u, --username string Username
4、登录完毕后就可以提交镜像了,就是一步docker push
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 # push自己的镜像到服务器上! [root@kuangshen tomcat]# docker push diytomcat The push refers to repos itory [docker.io/library/diytomcat] fcc7fccb8e04: Preparing b5577f344233: Preparing bdcb94365850: Preparing 1c5bd81521f5: Preparing 0683de282177: Preparing denied: requested access to the resource is denied #拒绝 # push镜像的问题? [root@kuangshen tomcat]# docker push kuangshen/diytomcat:1. 0 The push refers to repos itory [docker.io/kuangshen/diytomcat2] An image does not exist 1ocally with the tag: kuangshen/diytomcat2 # 解决，增加一个tag [root@kuangshen tomcat]# docker tag f8559daf1fc2 kuangshen/tomcat:1.0 # docker psuh上去 即可!自己发布的镜像尽量带上版本号. [root@kuangshen tomcat]# docker push kuangshen/tomcat:1.0 The push refers to repository [docker.io/kuangshen/tomcat] fcc7fccb8e04: Preparing b5577f344233: Preparing bdcb94365850: Preparing 1c5bd81521f5: Preparing 0683de282177: Preparing
提交的时候也是按照镜像的层级来进行提交的!
阿里云
阿里云容器镜像的就参考官方地址!
小结
Docker 网络 理解docker0 清空所有环境
测试
三个网络
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 # 测试 运行一个tomcat $ docker run -d -P --name tomcat01 tomcat # 查看容器内部网络地址 发现容器启动的时候会得到一个 eth0@if73 ip地址，docker分配！ $ docker exec -it tomcat01 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 72: eth0@if73: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default link/ether 02:42:ac:12:00:02 brd ff:ff:ff:ff:ff:ff link-netnsid 0 inet 172.18.0.2/16 brd 172.18.255.255 scope global eth0 valid_lft forever preferred_lft forever # 思考？ linux能不能ping通容器内部！ $ ping 172.18.0.2 PING 172.18.0.2 (172.18.0.2) 56(84) bytes of data. 64 bytes from 172.18.0.2: icmp_seq=1 ttl=64 time=0.126 ms 64 bytes from 172.18.0.2: icmp_seq=2 ttl=64 time=0.097 ms 64 bytes from 172.18.0.2: icmp_seq=3 ttl=64 time=0.083 ms 64 bytes from 172.18.0.2: icmp_seq=4 ttl=64 time=0.075 ms 64 bytes from 172.18.0.2: icmp_seq=5 ttl=64 time=0.104 ms 64 bytes from 172.18.0.2: icmp_seq=6 ttl=64 time=0.114 ms 64 bytes from 172.18.0.2: icmp_seq=7 ttl=64 time=0.081 ms # linux 可以 ping 通 docker 容器内部
原理
1、我们每启动一个docker容器，docker就会给docker容器分配一个ip，我们只要按照了docker，就会有一个docker0桥接模式，使用的技术是veth-pair 技术！
再次测试ip add
2 、在启动一个容器测试，发现又多了一对网络
1 2 3 4 # 我们发现这个容器带来网卡，都是一对对的 # veth-pair 就是一对的虚拟设备接口，他们都是成对出现的，一端连着协议，一端彼此相连 # 正因为有这个特性 veth-pair 充当一个桥梁，连接各种虚拟网络设备的 # OpenStac,Docker容器之间的连接，OVS的连接，都是使用evth-pair技术
3、我们来测试下tomcat01和tomcat02是否可以ping通
1 2 3 4 5 6 $ docker exec -it tomcat02 ping 172.18.02 PING 172.18.02 (172.18.0.2) 56(84) bytes of data. 64 bytes from 172.18.0.2: icmp_seq=1 ttl=64 time=0.115 ms 64 bytes from 172.18.0.2: icmp_seq=2 ttl=64 time=0.112 ms 64 bytes from 172.18.0.2: icmp_seq=3 ttl=64 time=0.108 ms # 结论：容器和容器之间是可以互相ping通！
网络模型图：
结论：tomcat01和tomcat02公用一个路由器，docker0。
所有的容器不指定网络的情况下，都是docker0路由的，docker会给我们的容器分配一个默认的可用ip。
小结：
Docker使用的是Linux的桥接，宿主机是一个Docker容器的网桥 docker0
Docker中所有网络接口都是虚拟的，虚拟的转发效率高（内网传递文件）
只要容器删除，对应的网桥一对就没了！
–link
思考一个场景：我们编写了一个微服务，database url=ip: 项目不重启，数据ip换了，我们希望可以处理这个问题，可以通过名字来进行访问容器？
1 2 3 4 5 6 7 8 9 10 11 12 13 14 $ docker exec -it tomcat02 ping tomca01 ping: tomca01: Name or service not known # 运行一个tomcat03 --link tomcat02 $ docker run -d -P --name tomcat03 --link tomcat02 tomcat 5f9331566980a9e92bc54681caaac14e9fc993f14ad13d98534026c08c0a9aef # 用tomcat03 ping tomcat02 可以ping通 $ docker exec -it tomcat03 ping tomcat02 PING tomcat02 (172.17.0.3) 56(84) bytes of data. 64 bytes from tomcat02 (172.17.0.3): icmp_seq=1 ttl=64 time=0.115 ms 64 bytes from tomcat02 (172.17.0.3): icmp_seq=2 ttl=64 time=0.080 ms # 用tomcat02 ping tomcat03 ping不通
探究：inspect！
docker inspect tomcat03
查看tomcat03里面的/etc/hosts发现有tomcat02的配置
–link 本质就是在hosts配置中添加映射
现在使用Docker已经不建议使用–link了！
自定义网络，不适用docker0！
docker0问题：不支持容器名连接访问！
自定义网络 容器互联
查看所有的 docker 网络
网络模式
bridge ：桥接 docker（默认，自己创建也是用bridge模式）
none ：不配置网络，一般不用
host ：和所主机共享网络
container ：容器网络连通（用得少！局限很大）
测试
1 2 3 4 5 6 7 8 9 10 11 12 # 我们直接启动的命令 --net bridge,而这个就是我们得docker0 # bridge就是docker0 $ docker run -d -P --name tomcat01 tomcat 等价于 => docker run -d -P --name tomcat01 --net bridge tomcat # docker0，特点：默认，域名不能访问。 --link可以打通连接，但是很麻烦！ # 我们可以 自定义一个网络 # --driver bridge 桥接 # --subnet 192.168.0.0/16 子网 # --gateway 192.168.0.1 mynet 网关 $ docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet ce470a4ed2a009854ac79947a9c4a667a1174be8df81b778563549aa1d3afe91
我们自己的网络就创建好了!
启动两个tomcat,再次查看网络情况
再次测试ping连接,现在不使用–link也可以ping名字!
我们自定义的网络docker当我们维护好了对应的关系，推荐我们平时这样使用网络！
好处：
redis -不同的集群使用不同的网络，保证集群是安全和健康的
mysql-不同的集群使用不同的网络，保证集群是安全和健康的
网络连通
1 2 3 4 5 6 7 # 测试打通 tomcat01 - mynet [root@iZ70q42pccuzt0Z ~]# docker network connect mynet tomcat01 # 连通之后就是将 tomcat01 放到了 mynet 网络下 # 一个容器两个ip! # 阿里云服务:公网ip 私网ip
1 2 3 4 5 6 7 8 9 10 11 # 01 连通ok [root@iZ70q42pccuzt0Z ~]# docker exec -it tomcat01 ping tomcat-net-01 PING tomcat-net-01 (192.168.0.3) 56(84) bytes of data. 64 bytes from tomcat-net-01.mynet (192.168.0.3): icmp_seq=1 ttl=64 time=0.115 ms 64 bytes from tomcat-net-01.mynet (192.168.0.3): icmp_seq=2 ttl=64 time=0.080 ms 64 bytes from tomcat-net-01.mynet (192.168.0.3): icmp_seq=3 ttl=64 time=0.087 ms 64 bytes from tomcat-net-01.mynet (192.168.0.3): icmp_seq=4 ttl=64 time=0.081 ms # 02 是依旧打不通的 [root@iZ70q42pccuzt0Z ~]# docker exec -it tomcat02 ping tomcat-net-01 ping: tomcat-net-01: Name or service not known
结论：假设要跨网络操作别人，就需要使用docker network connect 连通！
实战：部署Redis集群
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 # 创建网卡 docker network create redis --subnet 172.38.0.0/16 # 通过脚本创建六个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 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 # 通过脚本运行六个redis for port in $(seq 1 6);\ docker run -p 637${port}:6379 -p 1667${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-alpine3.11 redis-server /etc/redis/redis.conf docker run -p 6376:6379 -p 16676: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-1 docker exec -it redis-1 /bin/sh #redis默认没有bash所以用sh # 创建集群 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
docker搭建redis集群完成
我们使用docker之后，所有的技术都会慢慢变得简单起来！
SpringBoot微服务打包Docker镜像 1、构架springboot项目
2、打包应用
3、编写dockerfile
4、构建镜像
5、发布运行!
以后我们使用了Dokcer之后,给别人交付的就是-个镜像即可!
Docker Composer Docker Swarm / k8s CI/CD之jenkins 
