Docker概述
Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。
通俗来说，可以解决在我电脑上可以运行，为什么在你电脑上不能运行的问题
docker的核心思想和隔离，打包装箱，每个箱子是互相隔离的
通过隔离机制，可以将服务器利用到极致
docker十分的轻巧，docker容器技术也是一种虚拟机技术，因为轻巧，所以火
docker是基于go语言开发的，开源项目
比较docker和虚拟机技术的不同：
- 传统虚拟机，虚拟出一套硬件，运行一个完整的操作系统，然后在这个系统上安装和运行软件
- docker容器技术，容器内的应用直接运行在宿主机的内核上，容器是没有自己的内核的，也没有虚拟硬件，所以轻便
- 每个容器见是相互隔离的，每个容器都有一个属于自己的文件系统，互不影响
docker的基本组成
镜像（image）：
docker镜像就好比是一个模板，可以通过这个模板来创建容器服务，tomcat镜像 ==》run ==》tomcat01容器（提供服务），通过这个镜像可以创建多个容器（最终服务运行或者项目就是在容器中）
容器（container）：
docker利用容器技术，独立运行一个或者一组应用，通过镜像来创建
启动，停止，删除，基本命令
目前就可以把这个容器理解为是一个简易的linux系统
仓库（repository）：
仓库就是存放镜像的地方，分为公有仓库和私有仓库，例如docker hub、阿里云等
安装docker
查看帮助文档
https://docs.docker.com/engine/install/centos/
1、卸载老版本
yum remove docker \
docker-client \
docker-client-latest \
docker-common \
docker-latest \
docker-latest-logrotate \
docker-logrotate \
docker-engine2、安装docker需要的安装包
yum install -y yum-utils3、设置镜像仓库，这个不要根据官方文档的设置，国外网站慢
yum-config-manager \
--add-repo \
http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo4、更新yum 索引
yum makecache fast
5、安装
docker-ce 社区版
yum install docker-ce docker-ce-cli containerd.io6、启动docker
systemctl start docker可以使用docker version查看docker信息，可以判断是否安装成功
7、helloworld测试程序
docker run hello-world卸载docker
yum remove docker-ce docker-ce-cli containerd.io
#/var/lib/docker docker的默认工作路径
rm -rf /var/lib/docker底层原理
docker run的运行原理图
Docker是怎么工作的？
docker是一个Client - Server结构的系统，Docker的守护进程运行在宿主机上，通过Socket从客户端访问
DockerServer接收到DockerClient的命令就会执行
Docker为什么比VM快？
1、docker有着比虚拟机更少的抽象层
2、docker利用的是宿主机的内核，vm需要Guest OS ，CentOS
所以说，新建一个容器的时候，docker不需要像虚拟机一样重新加载一个操作系统内核，避免引导。而虚拟机需要加载GuestOS，分钟级别的，docker利用的是宿主机的操作系统，避免了这个过程，秒级启动
Docker常用命令
帮助命令
docker version #显示docker的版本信息
docker info #显示docker的系统信息，包括镜像和容器的数量
docker 命令 --help #帮助命令
执行docker info时出现警告
WARNING: bridge-nf-call-iptables is disabled
WARNING: bridge-nf-call-ip6tables is disabled
#修改配置文件
vi /etc/sysctl.conf
#在文件中加入下面两行
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
#保存后执行
sysctl -p
镜像命令
docker images
[root@localhost /]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
hello-world latest bf756fb1ae65 13 months ago 13.3kB
#解释
REPOSITORY 镜像的仓库源
TAG 镜像的标签
IMAGE ID 镜像id
CREATED 镜像的创建时间
SIZE 镜像的大小
#可选项
-a ，--all 列出所有的镜像
-q ，--quiet 只显示镜像的id 常用
docker search 搜索镜像
#可选项 通过收藏来过滤
--filter=STARS=3000 搜索出来的镜像就是STARS大于3000的
docker pull 下载镜像
指定版本下载镜像
docker pull 镜像名[:tag]
docker pull mysql
docker pull mysql:5.7
[root@localhost /]# docker pull mysql
Using default tag: latest #如果不写tag，默认就是latest
latest: Pulling from library/mysql
a076a628af6f: Pull complete #分层下载
f6c208f3f991: Pull complete
88a9455a9165: Pull complete
406c9b8427c6: Pull complete
7c88599c0b25: Pull complete
25b5c6debdaf: Pull complete
43a5816f1617: Pull complete
1a8c919e89bf: Pull complete
9f3cf4bd1a07: Pull complete
80539cea118d: Pull complete
201b3cad54ce: Pull complete
944ba37e1c06: Pull complete
Digest: sha256:feada149cb8ff54eade1336da7c1d080c4a1c7ed82b5e320efb5beebed85ae8c #防伪签名
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest # 真实地址
#等价于
docker pull mysql
docker pull docker.io/library/mysql:latest
docker rmi 删除镜像
docker rmi -f 镜像Id 也可以通过镜像仓库源名字删除，但是需要指定版本号，默认latest版本
删除多个镜像
docker rmi -f 镜像Id 镜像Id 镜像Id 镜像Id
删除所有镜像
docker rmi -f $(docker images -aq)
测试发现：
1、删除hello-world的时候，发现有容器正在使用该镜像，所以无法删除该镜像
2、下载了mysql的最新版本和5.7版本，直接执行docker rmi -f mysql 没有指定版本号的时候，是默认删除latest版本，删除完latest版本之后再次执行该命令，会报找不到mysql镜像，所以一般使用镜像id删除，或者带上镜像版本号进行删除
3、删除的时候只删除自己下载的文件层，不是都删，比如同时存在mysql latest和mysql 5.7的时候，删除latest的时候只是删除跟5.7不同的层，公有层是不会被删除的，分层下载，分层删除
容器命令
说明：有了镜像才可以创建容器
启动容器
docker run [可选参数] image
#参数说明
--name="Name" 容器名字 tomcat01 tomcat02 用来区分容器
-d 后台方式运行
-it 使用交互方式运行，进入容器查看内容
-p 指定容器的端口
-p ip:主机端口:容器端口
-p 主机端口:容器端口
-p 容器端口
容器端口
-P 随机指定端口
#测试 启动并进入容器 可以看到root后面的名字变了
从容器中退回主机
exit
列出所有运行中的容器
docker ps 列出当前正在运行的容器
d-a 列出当前正在运行的容器 + 带出历史运行过的容器
-n=? 显示最近创建的容器
-q 只显示容器id
退出容器
exit 直接停止容器并退出
Ctrl + P + Q 容器不停止退出
删除容器
docker rm 容器id # 删除指定的容器，不能删除正在运行的容器，如果要强制删除 rm -f
docker rm -f $(docker ps -aq) # 删除所有容器
docker ps -a -q|xargs docker rm # 删除所有容器
启动和停止容器的操作
docker start 容器id # 启动容器
docker restart 容器id # 重启容器
docker stop 容器id # 停止容器
docker kill 容器id # 强制停止当前容器
常用其他命令
后台启动容器
# docker run -d 镜像名
docker run -d centos
# 执行docker ps后，发现centos停止了，docker容器使用后台运行，就必须要有一个前台进程，docker发现没有应用，就会自动停止
查看日志
docker logs -f -t --tail 条数 容器id
编写一段shell脚本来测试日志
docker run -d centos /bin/sh -c "while true;do echo hahahahaha;sleep 1;done"
查看容器中的进程信息
docker top 容器id
查看容器多的元数据
docker inspect 容器id docker image inspect 镜像id（镜像名:版本号）
进入当前正在运行的容器
# 我们通常容器都是使用后台方式运行的，需要进入容器，修改一些配置
方式一：
docker exec -it 容器id bashShell
方式二：
docker attach 容器id
进去之后是进入到正在执行的代码行
# docker exec # 进入到容器后开启一个新的终端，可以在里面操作（常用）
#docker attach # 进入容器正在执行的终端，不会启动新的进程
比如说上面的例子，docker attach进入之后，就一直在输出shell脚本的东西，进入的是当前正在执行的终端
从容器内拷贝文件到主机上
docker cp 容器id：容器内路径 主机路径
不是正在运行的容器也可以进行数据拷贝，只要容器在，数据就在
小结
练习一：Docker安装Nginx
1、搜索镜像 docker search nginx 建议去dockerhub搜索，有帮助文档
2、下载镜像 docker pull nginx
3、运行 docker run -d --name nginx01 -p 3344:80 nginx
-d 后台运行
--name 给容器命名
-p 宿主机端口：容器内部端口
4、测试 curl http://localhost:3344
端口暴露的概念
每次修改nginx配置文件，都需要进入容器内部，十分的麻烦，后面会有数据卷技术，实现在容器外部提供一个映射路径，达到在外部修改文件内容，容器内部文件会自动同步修改的效果
练习二：docker安装tomcat
# 官方的使用
docker run -it --rm tomcat:9.0
#我们之前的启动都是后台，停止了容器之后，容器还是可以查到 docker run -it --rm ,一般用来测试，用完就删除，也就是说，这样启动之后，docker ps -a是查不到tomcat的
# 测试访问没有问题（404）
# 进入容器 docker exec -it tomcat01 /bin/bash
# 发现问题
1、linux命令少了
2、没有webapps 阿里云镜像的原因，，默认是最小的镜像，所有不必要的都剔除掉，保证最小可运行的环境
默认访问页面在 webapps.dist文件夹中
同上，如果有个外部映射，就可以不用进入容器进行项目部署了
练习三：部署es + kibanna
使用docker stats 容器id 查看cpu的状态
es十分耗内存，增加内存限制 启动的时候加 -e 环境配置修改 -e ES_JAVA_OPTS="-Xms64m -Xmx512m"
Docker镜像讲解
镜像是什么
镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件，它包含了运行某个软件所需的所有内容，包括代码、运行时库、环境变量和配置文件。
所有的应用可以直接打包成docker镜像，就可以直接跑起来了
如何得到镜像？
1、远程仓库拉取
2、dockerfile自己制作镜像
3、拷贝别人的
Docker镜像加载原理
commit镜像
# docker commit 提交容器成为一个新的副本
docker commit -m="提交的描述信息" -a="作者" 容器id 目标镜像名:[TAG]
启动官方的tomcat镜像，webapps文件夹下是没有文件的，将webapps.dist文件夹下的内容拷贝到webapps下，相当于是给原始的镜像层添加一个容器层，之后将容器打包成镜像，以后就可以使用自己制作的镜像了
容器数据卷
说白了数据卷就是目录挂载。
如果数据放在容器内，当容器删除之后，数据就丢失了，比如启动一个mysql，这样显然是不合理的，所以需要将容器内的数据挂载出来，放到liunx的目录中，或者说将配置文件的数据挂载出来，这样修改容器的配置时就不要频繁的进入容器了，主要是为了容器数据的持久化和数据共享。
使用数据卷
方式一： 以命令的方式进行挂载 -v
docker run -it -v 本机目录:容器内目录
docker run -it -v /home/ceshi:/home centos /bin/bash
挂载之后，容器内的数据会同步到linux中的文件夹中，在linux文件夹中添加数据也会同步到容器内
容器关闭后，linux文件夹中的数据还在，同时，在容器关闭的情况下对文件进行修改，重新启动容器后，在容器内对文件进行查看，发现同样进行了同步操作
利用数据卷技术启动mysql
docker run -d -p 3310: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
具名挂载和匿名挂载
# 匿名挂载
-v 容器内路径
docker run -d -P --name nginx01 -v /etc/nginx nginx
通过docker volume ls 查看卷挂载情况
这种的就是匿名挂载
# 具名挂载
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx
通过docker volume ls 查看卷挂载情况
这种的就是具名挂载 推荐使用具名挂载
通过docker volume inspect 卷名 可以查看详细信息
可以看出/var/lib/docker 是docker的工作目录
如何区别具名挂载、匿名挂载和指定路径挂载？
-v 容器内路径 匿名挂载
-v 卷名：容器内路径 具名挂载
-v /宿主机路径：容器内路径 指定路径挂载
拓展：
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:ro nginx
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:rw nginx
ro -- readonly -- 只读
rw -- read write -- 可读可写 默认
启动的时候对容器进行限定。
看到ro就可以知道，这个路径的数据只能通过宿主机进行操作，容器内部无法进行操作
初识Dockerfile
dockerfile就是用来构建docker镜像的构建文件
FROM centos
VOLUME ["volume01","volume02"] # dockerfile中直接配置了卷
CMD echo "===end==="
CMD /bin/bash
数据卷容器
docker run -it --name centos01 55b15991646b /bin/bash
docker run -it --name centos02 --volumes-from f88e592b2fc1 55b15991646b通过--volumes-from 可以实现容器间的数据共享
centos01就被称为是数据卷容器，其他容器都挂载在他上面，centos01创建的数据centos02可以查看，centos02创建的数据centos01也可以查看
删除01后，发现02上的数据依旧存在，数据是一种双向拷贝的概念
多个mysql实现数据共享
docker run -d -p 3310:3306 -v /etc/mysql/conf.d -v /var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7
docker run -d -p 3310:3306 -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 --volumes-from mysql01 mysql:5.7
# 这个时候，可以实现两个容器数据同步
结论：
容器之间配置信息的传递，数据卷容器的生命周期一直持续到没有容器使用为止
但是一旦持久化到本地，这个时候，本地数据是不会删除的
DockerFile
命令参数脚本
构建步骤：
1、编写一个dockerfile文件
2、docker build 构建称为一个镜像
3、docker run 运行镜像
4、docker push 发布镜像（dockerhub、阿里云镜像仓库）
Docker构建过程
基础知识：
1、每个关键字（指令）都必须是大写字母
2、执行从上到下顺序执行
3、#表示注释
4、每个指令都创建一个镜像层，并提交
dockerfile是面向开发的，以后发布项目，制作镜像，就需要编写dockerfile文件
DockerFile指令说明
FROM # 基础镜像，一切从这里开始构建
MAINTAINER # 镜像是谁写的，姓名+邮箱
RUN # 镜像构建时需要运行的命令
ADD # 步骤： 添加进去一些内容，比方说tomcat
WORKDIR # 镜像的工作目录
VOLUME # 挂载的目录
EXPOSE # 暴露端口配置
CMD # 指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT # 指定这个容器启动的时候要运行的命令，可以追加命令
ONBUILD # 当构建一个被继承Dockerfile这个时候就会运行ONBUILD的指令，触发指令
COPY # 类似ADD，将我们的文件拷贝到镜像中
ENV # 构建的时候设置环境变量
实战测试
DockerHub上99%的镜像都是由这个基础镜像开始的，FROM scratch，然后配置需要的软件和配置来进行的构建
FROM centos
MAINTAINER ly<948770104@qq.com>ENV MYPATH /usr/local
WORKDIR $MYPATH （原始的centos默认是根目录）RUN yum -y install vim
RUN yum -y install net-toolsEXPOSE 80
CMD echo $MYPATH
CMD echo "---end---"
CMD /bin/bash
docker build -f mydockerfile-centos -t mycentos:0.1 .
注意后面的点，这样构建出来就是一个自定义的centos，会有vim、ifconfig等指令
查看镜像的生成过程
docker history 镜像id
CMD和ENTRYPOINT的区别
CMD # 指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT # 指定这个容器启动的时候要运行的命令，可以追加命令
测试CMD
用dockerfile构建一个基础的镜像
FROM centos
CMD ["ls","-a"]
docker build -f mydockerfile-cmd -t cmdtest:1.0 .
运行后如图，会自动执行dockerfile中写的ls -a指令
但是想要在后面追加-l指令，会报错
想要正确执行需要 docker run fed4218ac7f7 ls -a -l 也就是需要在后面写出完整的指令，说明-l 指令会替换dockerfile中cmd定义的指令
测试ENTRYPOINT
用dockerfile构建一个基础的镜像
FROM centos
ENTRYPOINT ["ls","-a"]
docker build -f mydockerfile-entrypoint -t entrypointtest:1.0 .
跟cmd指令一样，运行后会自动执行dockerfile中entrypoint定义的指令
区别在于后面追加指令，-l不会替换dockerfile中entrypoint定义的指令，会往后追加指令
tomcat 镜像
1、准备镜像需要的压缩包
2、编写dockerfile，官方命名是Dockerfile，build的时候就不需要使用-f来指定文件了，默认会寻找这个官方命名的文件
FROM centos
MAINTAINER ly<948770104@qq.com>COPY readme.txt /usr/local/readme.txt
ADD jdk-8u281-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-9.0.22.tar.gz /usr/local/RUN yum -y install vim
ENV MYPATH /usr/local
WORKDIR $MYPATHENV JAVA_HOME /usr/local/jdk1.8.0_281
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.22
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.22
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/binEXPOSE 8080
CMD /usr/local/apache-tomcat-9.0.22/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.22/bin/logs/catalina.out
3、构建镜像
docker build -t diytomcat .
4、启动
docker run -d -p 9090:8080 --name hwhmtomcat -v /home/bwhm/build/tomcat/test:/usr/local/apache-tomcat-9.0.22/webapps/test -v /home/bwhm/build/tomcat/tomcatlogs:/usr/local/apache-tomcat-9.0.22/logs diytomcat
发布自己的镜像
DockerHub
https://hub.docker.com
1、登录
[root@localhost home]# 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 Username2、发布
docker push hwhm/diytomcat:1.0 (作者名/镜像名:版本)
小结
Docker网络
理解docker0
1：本机回环地址
2：局域网内网地址
3：docker0地址
下载一个tomcat镜像来做测试，查看容器内部的网络信息，类似于eth0@if7这样的ip地址，就是docker给分配的
docker run -d -P --name tomcat01 tomcat
docker exec tomcat01 ip add
测试是否能ping通docker分配的ip地址，发现可以ping通（毕竟这个容器的ip本身就是由服务器给分配的ip）
说明linux可以ping通docker容器内部
原理
1、我们每启动一个docker容器，docker就会给docker容器分配一个ip，我们只要安装了docker，就会有一个网卡docker0，桥接模式，使用的技术是veth-pair技术
启动tomcat容器后，再次测试ip addr
2、再启动一个tomcat容器，并查看容器内部网络信息
ip addr命令再次查看，发现又多了一对网卡
我们发现这个容器带来的网卡，都是成对出现的。
veth-pair 就是一对虚拟的网络设备接口，都是成对出现的，一端连着协议，一端彼此相连
正是因为这个特性，veth-pair 充当一个桥梁，连接着各种虚拟网络设备
OpenStac，docker容器之间的连接，OVS的连接，都是使用veth-pair技术
测试两个tomcat之间是否可以ping通（想想wifi，肯定是可以的）
tomcat01 ping tomcat02的时候，不是直连，是将请求发送到docker0上，再由docker0进行转发
结论： tomcat01和tomcat02是公用一个路由器的，docker0
所有容器在不指定网络的情况下，都是由docker0路由的，docker会给容器分配一个可用的ip
255.255.0.1/16
00000000.00000000.00000000.00000000
每个是8位，16代表两个域，也就是前面的两端不能动，后面的是一个局域网
如果是255.255.0.1/24
这就代表前三个域不能动，最后最后 0-255进行变化
小结
Docker中所有的网络接口都是虚拟的，虚拟的转发效率高
当删除容器后，对应的网桥就会自动删除，一堆虚拟的接口就会消失
--link（不推荐使用）
tomcat01通过服务名ping tomcat02的时候发现ping不通，可以通过--link来解决
docker run -d -P --name tomcat03 --link tomcat02 tomcat
测试是否已由tomcat02 ping 通tomcat03
ping不通，说明--link是单向的
进入tomcat03查看，发现在hosts文件下写入了tomcat02的ip，这就是--link的原理
自定义网络
查看所有的docker 网络
网络模式：
bridge : 桥接模式 （docker默认的，自己创建也使用bridge模式）
none ： 不配置网络
host ： 和宿主机共享网络
container ： 容器网络连通 （用的少，局限性大）
--net 是默认参数
docker run -d -P --name tomcat01 tomcat
docker run -d -P --name tomcat01 --net bridge tomcat
自定义一个网络
docker network create -d bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
查看自己创建的网络的详细信息
docker network inspect mynet
测试自己创建的网络
docker run -d -P --name tomcat-mynet-01 --net mynet tomcat
docker run -d -P --name tomcat-mynet-02 --net mynet tomcat
执行完之后，再次查看自己的网络
docker network inspect mynet
发现两个容器都通过自定义网络分配了ip
测试启动的两个tomcat在不使用--link的情况下，是否可以通过服务名ping通
自定义网络docker维护好了对应的关系，修复了docker0的缺陷，推荐使用
网络连通
两个网络，一个是默认的docker0网络，一个是自定义的mynet网络，自定义的网络下，两个容器可以通过容器名ping通，但是不同的网络下，是ping不通的，就比如说想要让tomcat-01连接到tomcat-net-01是连不通的，解决方法是将tomcat-01连接到mynet网络下，这样就可以连通了
docker run -d -P --name tomcat01 tomcat
docker run -d -P --name tomcat02 tomcat
将tomcat01容器连入mynet网络中，就可以通过容器名访问mynet网络中的容器
docker network connect --help
docker network connect mynet tomcat01
测试发现可以连通，查看一下mynet的信息
发现就是将tomcat01容器直接连入到mynet网络中，并分配一个mynet下的ip，也就是一个容器两个ip
结论： 如果要跨网络连通别人的容器，就需要使用docker network connect 连入网络
部署Redis集群
创建redis网络
docker network create redis --subnet 172.38.0.0/16
通过shell脚本创建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
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 yes
appendonly yes
EOF
done
启动redis
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.confdocker run -p 6372:6379 -p 16372:16379 --name redis-2 \
-v /mydata/redis/node-2/data:/data \
-v /mydata/redis/node-2/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.12 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.confdocker run -p 6373:6379 -p 16373:16379 --name redis-3 \
-v /mydata/redis/node-3/data:/data \
-v /mydata/redis/node-3/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.13 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.confdocker run -p 6374:6379 -p 16374:16379 --name redis-4 \
-v /mydata/redis/node-4/data:/data \
-v /mydata/redis/node-4/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.14 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.confdocker run -p 6375:6379 -p 16375:16379 --name redis-5 \
-v /mydata/redis/node-5/data:/data \
-v /mydata/redis/node-5/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.15 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.confdocker 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集群
进入随意一个容器
docker exec -it redis-1 /bin/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 1redis-cli -c
进入之后可以查看节点信息
cluster nodes
set a b 之后
发现是13执行的，再打开一个终端，关闭13，退出，重新进入redis-cli -c ,执行get a
这时从机就已经替换为主机了，查看节点信息
声明：文章内容都是狂神视频的笔记，跟着狂神在学习。
986
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
