本文详细介绍了Docker的基本概念、安装步骤、镜像与容器的区别、常用命令，以及DockerFile的构建和容器数据卷的使用。涵盖了镜像原理、分层理解、数据卷持久化、DockerFile实战和网络配置等内容。
一、Docker入门
1. 概述
1.1 基本介绍
Docker 是一个开源的应用容器引擎，基于 Go 语言 并遵从 Apache2.0 协议开源。
Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。
容器是完全使用沙箱机制，相互之间不会有任何接口（类似 iPhone 的 app）,更重要的是容器性能开销极低。
官方文档：https://docs.docker.com/
1.2 Docker能做什么？
比较Docker和虚拟机技术的不同：
- 传统虚拟机，虚拟出一条硬件，运行一个完整的操作系统，然后在系统中安装和运行软件
- 容器内的应用是直接运行在宿主机的内存中，容器是没有自己的内核的，也没有虚拟的硬件，所以就轻便了
- 每个容器间是互相隔离的，每个容器内都有一个属于自己的文件系统，互不影响
DevOps（开发、运维）
应用更快速的交付和部署
传统：一堆帮助文档，安装应用程序
Docker：打包镜像发布测试，一键运行
更便捷的升级和扩缩容
更简单的系统运维！
在容器化后，开发，测试环境都是高度一致的
更高效的计算资源利用
Docker是内核级别的虚拟化，可以在一个物理机上运行很多的容器实例
1.3 优势
Docker 是一个用于开发，交付和运行应用程序的开放平台。Docker 使您能够将应用程序与基础架构分开，从而可以快速交付软件。借助 Docker，您可以与管理应用程序相同的方式来管理基础架构。通过利用 Docker 的方法来快速交付，测试和部署代码，您可以大大减少编写代码和在生产环境中运行代码之间的延迟。
- 快速，一致地交付您的应用程序
- 响应式部署和扩展
- 在同一硬件上运行更多工作负载
1.4 Docker基本组成
镜像（Image）：
Docker镜像好比就是一个模板，可以通过这个模板来创建容器服务，通过这个镜像可以创建多个容器（最终服务运行或者项目运行就是在容器中的）
容器（container）：
Docker利用容器技术，独立运行一个或者一个组应用，通过镜像来创建的
启动，停止，删除，基本命令！
仓库（repository）：
仓库就是放镜像的地方！
仓库分为公有仓库和私有仓库
Docker Hub（默认是国外的）
2. 安装
2.1 环境准备
查看内核版本：uname -r
# 环境是3.10以上的
[root@ghc1 /]# uname -r
3.10.0-1062.18.1.el7.x86_64
查看系统配置：cat /etc/os-release
[root@ghc1 /]# cat /etc/os-release
NAME="CentOS Linux"
VERSION="7 (Core)"
...
2.2 安装
帮助文档
（1）卸载旧版本
yum remove docker \
docker-client \
docker-client-latest \
docker-common \
docker-latest \
docker-latest-logrotate \
docker-logrotate \
docker-engine
（2）需要的安装包
yum install -y yum-utils
（3）设置镜像仓库
# 默认是国外的，速度慢不建议！
yum-config-manager \
--add-repo \
https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo # 阿里云镜像
（4）更新yum软件包索引
yum makecache fast
（5）安装docker相关配置
docker-ce 是社区版，docker-ee 企业版
yum install docker-ce docker-ce-cli containerd.io
（6）启动docker
systemctl start docker
# 查看当前版本号，是否启动成功
docker version
# 设置开机自启动
systemctl enable docker
（7）运行hello-world测试
docker run hello-world
（8）查看下载的这个 hello-world 镜像
docker images
了解：卸载docker
# 1. 卸载依赖
yum remove docker-ce docker-ce-cli containerd.io
# 2. 删除资源 . /var/lib/docker是docker的默认工作路径
rm -rf /var/lib/docker
# /var/lib/docker docker默认工作路径
2.3 阿里云镜像加速
（1）进入控制台，搜索容器镜像服务
（2）依次执行官方的这四条命令
（3）配置使用
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
"registry-mirrors": ["https://kv5m5dm9.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker
docker配置完毕！
3. Run的流程和Docker原理
3.1 run流程
3.2 底层原理
Docker是怎么工作的？
Docker是一个 Client-Server 结构的系统，Docker的守护进程运行在主机上。通过Socket从客户端访问！
DockerServer 接收到一个 Docker-Client 的指令，就会执行
Docker为什么比VM虚拟机快？
1、Docker比虚拟机更少的抽象层
2、docker利用宿主机的内核，VM需要的是Guest OS
所以说，新建一个容器的时候，Docker新建一个容器的时候，不需要像虚拟机一样重新加载一个操作系统内核，直接利用宿主机的操作系统，是秒级的，而虚拟机是需要加载Guest OS。Docker和VM的对比如下：
4. Docker常用命令
4.1 帮助命令
docker version #查看docker的版本信息
docker info #查看docker的系统信息,包括镜像和容器的数量
docker 命令 --help #帮助命令(可查看可选的参数)
docker COMMAND --help #万能命令
命令的帮助文档地址:https://docs.docker.com/engine/reference/commandline/docker/
4.2 镜像命令
docker images：查看所有本地的主机上的镜像
[root@ghc1 ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
hello-world latest d1165f221234 6 months ago 13.3kB
#解释:
1.REPOSITORY 镜像的仓库源
2.TAG 镜像的标签
3.IMAGE ID 镜像的id
4.CREATED 镜像的创建时间
5.SIZE 镜像的大小
# 可选参数
-a,--all 列出所有镜像
-q,--quiet 只显示镜像的id
docker search：搜索镜像
[root@ghc1 ~]# docker search mysql
NAME DESCRIPTION STARS OFFICIAL AUTOMATED
mysql MySQL is a widely used, open-source relation… 11457 [OK]
mariadb MariaDB Server is a high performing open sou… 4348 [OK]
mysql/mysql-server Optimized MySQL Server Docker images. Create… 848 [OK]
......
# 可选参数，通过搜藏来过滤
--filter=STARTS=3000 # 搜索出来的镜像就是STARS大于3000的
docker pull：下载镜像
# 镜像名[:tag]
[root@ghc1 ~]# docker pull mysql
Using default tag: latest # 如果不写tag 就默认是latest
latest: Pulling from library/mysql
a330b6cecb98: Pull complete # 分层下载，docker images的核心，联合文件系统
9c8f656c32b8: Pull complete
88e473c3f553: Pull complete
062463ea5d2f: Pull complete
daf7e3bdf4b6: Pull complete
1839c0b7aac9: Pull complete
cf0a0cfee6d0: Pull complete
1b42041bb11e: Pull complete
10459d86c7e6: Pull complete
b7199599d5f9: Pull complete
1d6f51e17d45: Pull complete
50e0789bacad: Pull complete
Digest: sha256:99e0989e7e3797cfbdb8d51a19d32c8d286dd8862794d01a547651a896bcf00c
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest # 真实地址
# 两个命令等价
docker pull mysql
docker pull docker.io/library/mysql:latest # 真实地址
# 指定版本下载
docker pull mysql:5.7
[root@ghc1 ~]# docker pull mysql:5.7
5.7: Pulling from library/mysql
a330b6cecb98: Already exists # 已经存在，分层下载的好处
9c8f656c32b8: Already exists
88e473c3f553: Already exists
062463ea5d2f: Already exists
daf7e3bdf4b6: Already exists
1839c0b7aac9: Already exists
cf0a0cfee6d0: Already exists
fae7a809788c: Pull complete
dae5a82a61f0: Pull complete
7063da9569eb: Pull complete
51a9a9b4ef36: Pull complete
Digest: sha256:d9b934cdf6826629f8d02ea01f28b2c4ddb1ae27c32664b14867324b3e5e1291
Status: Downloaded newer image for mysql:5.7
docker.io/library/mysql:5.7
docker rmi：删除镜像
# 通过名字或者id删除指定的容器
[root@ghc1 ~]# docker rmi -f 容器id
# 删除多个
[root@ghc1 ~]# docker rmi -f 容器id 容器id 容器id
# 递归删除
[root@ghc1 ~]# docker rmi -f $(docker images -aq)
4.3 容器命令
说明：有了镜像才可以创建容器，linux，下载一个centos镜像来测试学习
docker pull centos
新建容器，并启动
docker run [可选参数] image
# 参数说明
--name="Name" 容器名字，用来区分容器
-d 以后台方式运行
-it 使用交互方式运行，进入容器查看内容
-p (小写)指定容器的端口 -p 8080:8080
-p ip：主机端口：容器端口
-p 主机端口：容器端口（常用）
-p 容器端口
-P (大写)随机指定端口
测试：
# 启动并进入容器
[root@ghc1 ~]# docker run -it centos /bin/bash
# 查看容器内的centos，基础版本，很多命令都不完善
[root@059a3610cf87 /]# ls
bin etc lib lost+found mnt proc run srv tmp var
dev home lib64 media opt root sbin sys usr
# 退出
[root@059a3610cf87 /]# exit
exit
列出所有运行中的容器
docker ps：查看运行中的容器- -a 列出当前正在+历史运行过的容器
- -n=? 显示最近创建的容器
- -q 只显示容器的编号
[root@ghc1 ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
[root@ghc1 ~]# docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
059a3610cf87 centos "/bin/bash" 3 minutes ago Exited (0) About a minute ago busy_tesla
5e6fe09ab827 d1165f221234 "/hello" 18 hours ago Exited (0) 18 hours ago loving_tereshkova
55a0d9e36d7f d1165f221234 "/hello" 2 weeks ago Exited (0) 2 weeks ago loving_chaplygin
[root@ghc1 ~]# docker ps -a -n=1
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
059a3610cf87 centos "/bin/bash" 5 minutes ago Exited (0) 3 minutes ago busy_tesla
[root@ghc1 ~]# docker ps -aq
059a3610cf87
5e6fe09ab827
55a0d9e36d7f
退出容器
exit # 直接容器停止并退出
Ctrl + P + Q # 容器不停止退出
删除容器
# 删除指定容器，不能删除正在运行的容器，如果要强制删除要 rm -f
docker rm 容器id
# 递归删除
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 # 强制停止当前容器
4.4 常用其他命令
后台启动容器
docker run -d 镜像名
[root@ghc1 ~]# docker run -d centos
# 问题 docker ps,发现centos停止了
# 常见的坑：docker 容器使用后台运行，就必须要有一个前台进程，docker发现没有应用，就会自动停止
查看日志
docker logs- -tf 显示日志
- –tail num 要显示日志条数
# 容器没有日志
# 自己编写一端shell脚本
[root@ghc1 ~]# docker run -d centos /bin/sh -c "while true;do echo ghc;sleep 1;done"
8cabf17d10047484cd17275472fe66090b4aae54b0362bbf980b88ec3d34ee41
[root@ghc1 ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
8cabf17d1004 centos "/bin/sh -c 'while t…" 4 seconds ago Up 3 seconds zen_pascal
# 显示日志
# 显示指定行数的日志
[root@ghc1 ~]# docker logs -tf --tail 10 8cabf17d1004
# 显示
查看容器中的进程信息
top
查看进行的元数据
docker inspect 容器id
进入当前正在进行的容器
因为通常我们的容器都是使用后台方式来运行的，有时需要进入容器修改配置
- 方式一：
docker exec -it 容器id BashShell
[root@ghc1 ~]# docker exec -it 8cabf17d1004 /bin/bash
[root@8cabf17d1004 /]# ls
bin etc lib lost+found mnt proc run srv tmp var
dev home lib64 media opt root sbin sys usr
- 方式二：
docker attach 容器id
[root@ghc1 ~]# docker attach 8cabf17d1004
正在执行当前的代码...
区别：
docker exec 进入容器后开启一个新的终端，可以再里面操作（常用）
docker attach 进入容器正在执行的终端，不会启动新的终端
从容器内拷贝文件到主机上
docker cp 容器id:容器内路径 目的地主机路径
# 进入docker容器内部
[root@ghc1 home]# docker attach 86f36afa41e7
# 容器内新建一个文件
[root@86f36afa41e7 /]# cd /home
[root@86f36afa41e7 home]# ls
[root@86f36afa41e7 home]# touch test.java
[root@86f36afa41e7 home]# ls
test.java
[root@86f36afa41e7 home]# exit
exit
# 退出后将文件拷贝到主机上
[root@ghc1 home]# docker cp 86f36afa41e7:/home/test.java /home
[root@ghc1 home]# ls
es ggg ghc.java jdk-11.0.11_windows-x64_bin.exe redis test.java www
# 拷贝是一个手动过程，未来使用 -v 卷的技术，可以实现自动同步
4.5 小结
attach # 当前shell下attach连接指定运行镜像
build # 通过Dockerfile定制镜像
commit # 提交当前容器为新的镜像
cp # 从容器中拷贝指定文件或目录到宿主机中
create # 创建一个新的容器，同tun，但不企叮咚容器
diff # 查看 docker容器变化
events # 从docker服务获取容器实时事件
exec # 在已存在的容器上运行命令
export # 导出容器的内容流作为一个tar归档文件[对呀 import]
history # 展示一个镜像形成历史
images # 列出系统当前镜像
import # 从tar包中的内容创建一个新的文件系统映像
info # 显示系统相关信息
inspect # 查看容器详细信息
kill # kill指定docker容器
load # 从一个tar包中加载一个镜像[对应 save]
login # 注册或者登录一个docker源服务器
logout # 从当前docker register 退出
logs # 输出当前容器日志信息
port # 查看档映射端口对应的容器内部源端口
pause # 暂停容器
ps # 累出容器列表
pull # 从docker镜像源服务器拉取指定镜像或者库镜像
push # 推送指定镜像或者库镜像至docker源服务器
restart # 重启运行的容器
rm # 移除一个或者多个容器
rmi # 移除一个或多个镜像[无容器使用该镜像才可删除，否则需删除相关容器才可进行或 -f 强制删除]
run # 创建一个新的容器并运行一个命令
save # 保存一个镜像为一个tar包[对应load]
search # 在docker hub中搜索镜像
start # 启动容器
stop # 停止容器
tag # 给源镜像打标签
top # 查看容器中运行的进程信息
unpause # 取消暂停容器
version # 查看docker版本号
wait # 截取容器停止时的退出状态值
4.6 作业练习
4.6.1 部署Nginx
# 搜索镜像
[root@iZwz99osrzvcx9zd72bqslZ home]# docker search nginx
# 下载nginx
[root@iZwz99osrzvcx9zd72bqslZ home]# docker pull nginx
# 启动nginx 后台启动 起名字 暴露端口号:默认端口号
[root@iZwz99osrzvcx9zd72bqslZ home]# docker run -d --name nginx01 -p 3344:80 nginx
# 查看容器
[root@iZwz99osrzvcx9zd72bqslZ home]# docker ps
# 测试
[root@iZwz99osrzvcx9zd72bqslZ home]# curl localhoast:3344
# 进入容器
[root@iZwz99osrzvcx9zd72bqslZ home]# docker exec -it nginx01 /bin/bash
root@f553a6beccf2:/# whereis nginx
nginx: /usr/sbin/nginx /usr/lib/nginx /etc/nginx /usr/share/nginx
root@f553a6beccf2:/# cd /etc/nginx
root@f553a6beccf2:/etc/nginx# ls
conf.d fastcgi_params mime.types modules nginx.conf scgi_params uwsgi_params
网址输入：http://119.23.109.216:3344/
端口映射：
思考：每次改动nginx配置文件，都需要进入容器内部，十分麻烦，要是可以在容器外部提供一个映射路径，达到在容器外部修改文件，容器内部就可以自动修改？ -v 数据卷技术
4.6.2 部署Tomcat
# 官方的使用
docker run -it --rm toncat:9.0
# 我们之前的启动都是后台，停止了容器知乎，容器还是可以查到，docker run -it --rm 一般用来测试，用完即删
# 下载启动tomcat
docker pull tomcat
# 启动运行
docker run -d -p 3355:8080 --name tomcat01 tomcat
# 进入容器 发现问题 1.linux命令少了 2.webapps无内容
# 原因是阿里云镜像，默认是最小的镜像，所有不必要的都剔除
# 保证最小可运行的环境
docker exec -it tomcat01 /bin/bash
# 此时可以访问 http://119.23.109.216:3355/
root@b4dc4c915ec0:/usr/local/tomcat# cd webapps.dist/
root@b4dc4c915ec0:/usr/local/tomcat# cp -r webapps.dist/* webapps
4.6.3 部署es
# es 暴露的端口很多
# es 十分的耗内存
# es 的数据一般需要放置到安全目录
# 启动es
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.6.2
# 启动之后，服务器非常很卡，es十分占内存 docker stats 查看CPU状态
# 测试es是否启动成功
curl locathost:9200
# 增加内存限制，修改配置文件 -e 环境配置修改
docker run -d --name elasticsearch02 -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPS="Xms64m -Xms512m" elasticsearch:7.6.2
# 测试
curl localhost:9200
5. 可视化面板
- Portainer（先用这个）
- Rancher（CI/CD再用）
什么是Portainer？
Docker 图形化界面管理工具，提供一个后台面板供我们操作
docker run -d -p 8088:9000 \
--restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer
访问测试：外网 8088
登录 设置密码 并进入面板
6. Docker镜像讲解
6.1 镜像是什么
镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件，它包含运行某个软件所需要的所有内容，包括代码，运行时（一个程序在运行或者在被执行的依赖）、库，环境变量和配置文件。
所有的应用，直接打包docker镜像，就可以直接跑起来
如何得到镜像：
- 从远程仓库下载
- 别人拷贝给你
- 自己制作一个镜像 dockerfile
6.2 Docker镜像加载原理
UnionFS（联合文件系统）
UnionFS（ 联合文件系统）：Union文件系统( UnionFS)是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统 下(unite several directories into a single virtual filesvstem)。 Union 文件系统是 Docker 镜像的基础。镜像可以通过分层来进行继承 ，基于基础镜像（没有父镜像〕，可以制作各
种具体的应用镜像。
特性：一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统乐加起来，这样最终的
文件系统会包含所有底层的文件和目录
Docker镜像加载原理
docker的镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFS。
bootfs(boot file system)主要包含bootloader和kernel,bootloader主要是引导加载kernel, Linux刚启动时会加载bootfs文件系
统，在Docker镜像的最底层是bootfs。这一层与我们典型的Linux/Unix系統是一样的，包含boot加载器和内核。当boot加载完成
之后幣个内核就都在内存中了，此时内存的使用权已由bootfs转交给内核，此时系统也会卸载bootfs.
rootfs (root file system)，在bootfs之上。包含的就是典型 Linux 系統中的 /dev. /proc,/bin,letc 等标准目录和文件。rootis就星
各种不同的操作系统发行版，比如Ubuntu，Centos等等
平时安装虚拟机的Centos都要好几个g，为什么Docker才几百M？
对于一个精简的OS，rootfs可以很小，只需要包含最基本的命令，工具和程序库就可以了，因为底层直接用Host的kernel，自己只需要提供rootfs就可以了，由此可见对于不同的Linux发行版，bootfs基本是一致的，rootfs会有差别，因此不同的发行版可以公用bootfs
虚拟机是分钟级别，容器是秒级。
6.3 分层理解
分层的镜像
我们可以去下载一个镜像，注意观察下载的日志输出，可以看到是一层一层在下载
使用分层结构，可以更好的资源共享！
6.4 Commit镜像
docker commit # 命令提交容器成为一个新的版本
docker commit -m="提交的描述信息" -a="作者" 容器id 目标镜像名:[TAG]
实战测试：
# 启动一个默认的tomcat
[root@iZwz99osrzvcx9zd72bqslZ /]# docker run -it -p 8080:8080 tomcat
[root@iZwz99osrzvcx9zd72bqslZ /]# docker exec -it 81462ba2d2ba /bin/bash
root@81462ba2d2ba:/usr/local/tomcat# cp -r webapps.dist/* webapps
# 将我们操作过的容器通过commit提交为一个镜像！我们以后就使用我们修改过的镜像即可，这就是我们自己的一个修改的镜像
[root@iZwz99osrzvcx9zd72bqslZ /]# docker commit -a="ghc" -m="add webapps app" 81462ba2d2ba tomcat03:1.0
sha256:e361c3d259b06c767f9a76eb84ce5e2791231c58ba7e17e259450b4e4d6015c0
[root@iZwz99osrzvcx9zd72bqslZ /]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
tomcat03 1.0 e361c3d259b0 9 seconds ago 684MB
二、Docker容器数据卷
1. 概念
什么是容器数据卷？
Docker是将应用和环境打包成一个镜像。如果数据在容器中，如果容器删除，数据就会丢失。
需求：数据持久化
容器之间可以有一个数据共享的技术！docker容器中产生的数据，同步到本地，这就是卷技术。
目录的挂载，将我们的容器内的目录，挂在到Linux上面
总结一句话：容器的持久化和同步操作！容器间也是可以数据共享的！
数据卷特点：
- 数据卷可在容器之间共享或重用数据
- 卷中的更改可以直接生效
- 数据卷中的更改不会包含在镜像的更新中
- 数据卷的生命周期一直持续到没有容器使用它为止
2. 使用数据卷
方式一：直接使用命令挂载 -v
docker run -it -v 主机目录:容器内目录
测试：
# 将主机目录/home/test和容器/home建立数据卷，首先在容器目录下创建test.java文件，再去主机目录下查看是否有该文件。
[root@iZwz99osrzvcx9zd72bqslZ ~]# docker run -it -v /home/test:/home centos /bin/bash
[root@iZwz99osrzvcx9zd72bqslZ ~]# cd /home
[root@iZwz99osrzvcx9zd72bqslZ home]# ls
jdk11 test
# 通过docker inspect 容器id 查看怎么挂载的
[root@iZwz99osrzvcx9zd72bqslZ home]# docker inspect 9100bd692df3
测试文件的同步：双向绑定
再测试：
1.停止容器
2.宿主机上修改文件
3.启动容器
4.容器内的数据依旧是同步的
3. 实战：安装MySQL
思考：MySQL的数据持久化问题
# 获取镜像
[root@iZwz99osrzvcx9zd72bqslZ home]# docker pull mysql:5.7
# 运行容器，需要做数据挂载
# 安装启动mysql的时候，需要配置密码
# -d 后台运行 -p 端口映射 -v 卷挂载 -e 环境配置 --name 容器名字
[root@iZwz99osrzvcx9zd72bqslZ home]# 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
# 通过sqlyog测试连接
# sqlyog -- 连接到服务器3310 -- 3310和容器内的3306映射
# 在本地测试 创建一个数据库，查看一下我们映射的路径是否OK
假设将容器删除，发现挂载到本地的数据卷依旧没有丢失，这就实现了容器数据持久化功能！
4. 具名挂载和匿名挂载
匿名挂载
- 匿名挂载就是在指定数据卷的时候，不指定容器路径对应的主机路径，这样对应映射的主机路径就是默认的路径/var/lib/docker/volumes/中自动生成一个随机命名的文件夹。
# 匿名挂载
-v 容器内路径！
# 只指定容器内的 没有指定容器外的
docker run -d -P --name nginx001 -v /etc/nginx nginx
# 查看所有的卷的情况
docker volume ls
DRIVER VOLUME NAME
local 2066ea619b33810e465e7b913257c0ed2bf8c4d089351b036f316e62c9092127
local e4df8e00e837c1800f9ad1ff70a7f61df26ea5d71ca20dace865a0a37b4dd6bf
# 这些就是匿名挂载，我们在 -v 只写了容器内的路径，没有写容器外的路径
具名挂载
- 具名挂载，就是指定文件夹名称，区别于指定路径挂载，这里的指定文件夹名称是在Docker指定的默认数据卷路径下的。通过
docker volume ls命令可以查看当前数据卷的目录情况。
# 具名挂载
# 通过 -v 卷名:容器内路径
docker run -d -P --name nginx002 -v juming-nginx:/etc/nginx nginx
# 查看一下卷
[root@iZwz99osrzvcx9zd72bqslZ ~]# docker volume inspect juming-nginx
[
{
"CreatedAt": "2021-09-25T10:30:08+08:00",
"Driver": "local",
"Labels": null,
"Mountpoint": "/var/lib/docker/volumes/juming-nginx/_data",
"Name": "juming-nginx",
"Options": null,
"Scope": "local"
}
]
所有的docker容器内的卷，没有指定木库的情况下，都是在/var/lib/doc/volumes/xxxx/_data
我们通过具名挂载，可以方便找到一个卷，大多数情况使用具名挂载
如何确定匿名和具名，还是指定路径挂载？
-v 容器内路径 # 匿名挂载
-v 卷名:容器内路径 # 具名挂载
-v /宿主机路径::容器内路径 # 指定路径挂载
拓展：
# 通过 -v 容器内路径:ro 或 rw 改变读写权限
ro readonly # 只读
rw readwrite # 可读可写
# 一旦设置了容器权限，容器对我们挂载出来的内容就有限定了
docker run -d -P --name nginx002 -v juming-nginx:/etc/nginx:ro nginx
docker run -d -P --name nginx002 -v juming-nginx:/etc/nginx:rw nginx
# ro 说明这个路径只能通过宿主机来改变，容器内部不能操作，默认rw
6. 初识 Dockerfile
DockerFile就是用来构建docker镜像的构建文件！就是命令脚本
通过这个脚本可以生成镜像，镜像是一层一层的，脚本的每个命令都是一层
# 创建一个dockerfile文件
# 文件内容,指令大写
[root@iZwz99osrzvcx9zd72bqslZ docker-test-volume]# pwd
/home/docker-test-volume
[root@iZwz99osrzvcx9zd72bqslZ docker-test-volume]# vim dockerfile1
[root@iZwz99osrzvcx9zd72bqslZ docker-test-volume]#
[root@iZwz99osrzvcx9zd72bqslZ docker-test-volume]# cat dockerfile1
FROM centos
VOLUME ["volume01","volume02"] # 匿名挂载
CMD echo "----end----"
CMD /bin/bash
[root@iZwz99osrzvcx9zd72bqslZ docker-test-volume]# docker build -f dockerfile1 -t ghc/centos .
......
[root@iZwz99osrzvcx9zd72bqslZ docker-test-volume]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
ghc/centos latest 09257d2a9e51 About a minute ago 231MB
启动自己写的容器
[root@iZwz99osrzvcx9zd72bqslZ docker-test-volume]# docker run -it 09257d2a9e51 /bin/bash
这个卷和外部一定有一个同步的目录
查看一下挂载路径，并测试是否同步！
这种方式未来使用的会很多，因为我们通常会构建自己的镜像
假设构建镜像时候没有挂在卷，要手动镜像挂载 ，-v卷名：容器内路径
7. 容器数据卷
测试：
# 启动docker01
[root@iZwz99osrzvcx9zd72bqslZ docker-test-volume]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
ghc/centos latest 50c8d3d6179f 11 seconds ago 231MB
[root@iZwz99osrzvcx9zd72bqslZ docker-test-volume]# docker run -it --name docker01 50c8d3d6179f
ctrl+P+Q
# 启动docker02继承01
[root@iZwz99osrzvcx9zd72bqslZ docker-test-volume]# docker run -it --name docker02 --volumes-from docker01 50c8d3d6179f
# 测试在01中创建
[root@iZwz99osrzvcx9zd72bqslZ data]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORT
a4f6d0b0fc6e 50c8d3d6179f "/bin/sh -c /bin/bash" 50 seconds ago Up 50 seconds
8b61e4a4822e 50c8d3d6179f "/bin/sh -c /bin/bash" 3 minutes ago Up 3 minutes
[root@iZwz99osrzvcx9zd72bqslZ data]# docker attach 8b61e4a4822e
[root@8b61e4a4822e /]# cd volume01
[root@8b61e4a4822e volume01]# touch docker01
[root@8b61e4a4822e volume01]# ls
docker01
# 在创建一个docker03
[root@iZwz99osrzvcx9zd72bqslZ docker-test-volume]# docker run -it --name docker03 --volumes-from docker01 50c8d3d6179f
[root@3ce59f1eb231 /]# ls
bin etc lib lost+found mnt proc run srv tmp var volume02
dev home lib64 media opt root sbin sys usr volume01
[root@3ce59f1eb231 /]# cd volume01
[root@3ce59f1eb231 volume01]# ls
docker01
# 在03中创建文件，01中也会显示
# 删除docker01
[root@iZwz99osrzvcx9zd72bqslZ data]# docker rm -f 8b61e4a4822e
8b61e4a4822e
# 查看docker02 03 文件依然存在
[root@3ce59f1eb231 volume01]# ls
docker01 docker03
是一个双向拷贝的概念！三个容器之间是互相隔离的，但是数据共享
多个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 mysql5.7
# 这个时候，可以实现两个容器数据同步
结论
- 容器之间配置信息的传递，数据卷容器的生命周期一直持续到没有容器使用为止
- 但是一旦持久化到了本地，这个时候，本地的数据是不会删除的
三、DockerFile
1. 介绍
dockerfile 是用来构建docker镜像的文件，就是一个命令参数脚本
构架步骤：
1、编写一个dockerfile文件
2、docker build 构建成为一个镜像
3、docker run 运行镜像
4、docker push 发布镜像（DockerHub、阿里云镜像仓库）
很多官方的镜像都是基础包，很多功能没有，我们通常会自己搭建自己的镜像。
docker镜像构建过程（结构图）：
2. DockerFile构建过程
基础知识：
1、每个保留关键字（指令）都必须大写
2、执行从上到下顺序执行
3、 # 表示注释
4、每一个指令都会创建提交一个新的镜像层，并提交
DockerFile是面向开发的，我们以后要发布项目，做镜像，就需要编写dockerfile文件。
**DockerFIle：**构建文件，定义了一切的步骤
**DockerImages：**通过DockerFile生成的镜像，最终发布和运行的产品
**Docker容器：**容器就是镜像运行起来提供服务器
3. DockerFile指令
| 指令 | 说明 |
|---|---|
| FROM | 指定基础镜像 |
| MAINTAINER | 镜像是谁写的，姓名+邮箱 |
| RUN | 镜像构建的时候需要运行的命令 |
| ADD | 将本地文件添加到容器中，tar类型文件会自动解压(网络压缩资源不会被解压)，可以访问网络资源，类似wget |
| WORKDIR | 镜像的工作目录 |
| VOLUME | 挂载的目录 |
| EXPOSE | 暴露端口配置 |
| CMD | 指定这个容器启动的时候要运行的命令（只有最后一个会生效），可被替代 |
| EMTRYPOINT | 指定这个容器启动的时候要运行的命令，可以追加命令 |
| ONBUILD | 当构建一个被继承DockerFile，这个时候就会运行ONBUILD的指令，触发指令 |
| COPY | 功能类似ADD，但是是不会自动解压文件，也不能访问网络资源，将文件拷贝到镜像中 |
| ENV | 构建的时候设置环境变量 |
4. 实战：构建自己的Centos
Docker Hub 中大多镜像都是从 FROM scratch 开始的，然后配置我们需要的软件和配置来进行构建
创建centos
# 1.编写dockerfile配置文件
[root@iZwz99osrzvcx9zd72bqslZ dockerfile]# vim mydockerfile-centos
[root@iZwz99osrzvcx9zd72bqslZ dockerfile]# cat mydockerfile-centos
FROM centos
MAINTAINER ghc<1169263699@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
# 2.通过文件构建镜像
# docker build -f 文件路径 -t 镜像名:版本号 .
[root@iZwz99osrzvcx9zd72bqslZ dockerfile]# docker build -f mydockerfile-centos -t mycentos:1.0 .
...
Successfully built 4dea7ce838d2
Successfully tagged mycentos:1.0
# 3.测试运行
[root@iZwz99osrzvcx9zd72bqslZ dockerfile]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
mycentos 1.0 4dea7ce838d2 About a minute ago 336MB
...
[root@iZwz99osrzvcx9zd72bqslZ dockerfile]# docker run -it 4dea7ce838d2
[root@622c3787d5ce local]# pwd
/usr/local
比较：
我们可以列出本地镜像的变更历史
docker history
5. CMD 和 ENTRYPOINT 区别
-
CMD
-
指定这个容器启动的时候要运行的命令（只有最后一个会生效） ，可被替代
-
EMTRYPOINT
- 指定这个容器启动的时候要运行的命令，可以追加命令
测试CMD命令：
# 构建 dockerfile文件
[root@iZwz99osrzvcx9zd72bqslZ dockerfile]# vim dockerfile-cmd-test
[root@iZwz99osrzvcx9zd72bqslZ dockerfile]# docker build -f dockerfile-cmd-test -t cmdtest
[root@iZwz99osrzvcx9zd72bqslZ dockerfile]# cat dockerfile-cmd-test
FROM centos
CMD ["ls","-a"] # 展示目录
# 构建镜像
[root@iZwz99osrzvcx9zd72bqslZ dockerfile]# docker build -f dockerfile-cmd-test -t cmdtest .Sending build
...
# 运行，发现ls-a执行
[root@iZwz99osrzvcx9zd72bqslZ dockerfile]# docker run 19087ea81046
.
..
.dockerenv
bin
dev
etc
home
lib
lib64
lost+found
media
mnt
...
# 想追加一个命令 -l ls-al
# 报错
[root@iZwz99osrzvcx9zd72bqslZ dockerfile]# docker run 19087ea81046 -l
docker: Error response from daemon: OCI runtime create failed: container_linux.go:380: starting container process caused: exec: "-l": executable file not found in $PATH: unknown.
ERRO[0000] error waiting for container: context canceled
# cmd情况下，-l替换了cmd命令，-l并不是命令，所以报错
测试ENTRYPOINT：
[root@iZwz99osrzvcx9zd72bqslZ dockerfile]# vim dockerfile-cmd-entrypoint
[root@iZwz99osrzvcx9zd72bqslZ dockerfile]# cat dockerfile-cmd-entrypoint
FROM centos
ENTRYPOINT ["ls","-a"]
[root@iZwz99osrzvcx9zd72bqslZ dockerfile]# docker build -f dockerfile-cmd-entrypoint -t entrypoint-test .
[root@iZwz99osrzvcx9zd72bqslZ dockerfile]# docker run 15337a46019c
.
..
.dockerenv
bin
dev
etc
home
lib
lib64
lost+found
media
mnt
opt
proc
root
run
sbin
srv
...
# 追加命令，直接追加在ENTRYPOINT后面
[root@iZwz99osrzvcx9zd72bqslZ dockerfile]# docker run 15337a46019c -l
total 56
drwxr-xr-x 1 root root 4096 Sep 25 08:06 .
drwxr-xr-x 1 root root 4096 Sep 25 08:06 ..
-rwxr-xr-x 1 root root 0 Sep 25 08:06 .dockerenv
lrwxrwxrwx 1 root root 7 Nov 3 2020 bin -> usr/bin
drwxr-xr-x 5 root root 340 Sep 25 08:06 dev
drwxr-xr-x 1 root root 4096 Sep 25 08:06 etc
drwxr-xr-x 2 root root 4096 Nov 3 2020 home
lrwxrwxrwx 1 root root 7 Nov 3 2020 lib -> usr/lib
lrwxrwxrwx 1 root root 9 Nov 3 2020 lib64 -> usr/lib64
drwx------ 2 root root 4096 Sep 15 14:17 lost+found
....
6. 实战：Tomcat镜像
1、准备镜像文件 tomcat压缩包，jdk压缩包！
2、编写Dockerfile文件，官方命名Dockerfile，build会自动寻找这个文件，不需要 -f 指定了
touch readme.txt
vim Dockerfile
FROM centos
MAINTAINER ghc<1169263699@qq.com>
COPY readme.txt /usr/local/readme.txt
ADD jdk-8u301-linux-i586.tar.gz /usr/local/
ADD apache-tomcat-9.0.52.tar.gz /usr/local/
RUN yum -y install vim
ENV MYPATH /usr/local
WORKDIR $MYPATH
ENV JAVA_HOME /usr/local/jdk1.8.0_301
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.52
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.52
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
EXPOSE 8080
CMD /usr/local/apache-tomcat-9.0.52/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.52/bin/logs/catalina.out
3、构建镜像
[root@iZwz99osrzvcx9zd72bqslZ tomcat]# docker build -t divtomcat:1.0 .
4、启动生成的镜像，构建Tomcat容器
这里设置了数据卷，宿主机的/home/dockerfile/tomcat/test对应该容器的/usr/local/apache-tomcat-9.0.52/webapps/test。这样关于test项目的修复只需要在宿主机上修改就可以了，不需要进入到容器中修改。
[root@iZwz99osrzvcx9zd72bqslZ tomcat]# docker run -d -p 9090:8080 --name ghctomcat -v /home
/ghc/tomcat/test:/usr/local/apache-tomcat-9.0.52/webapps/test -v /home/ghc/tomcat/tomcatlogs/:/usr/local/apache-tomcat-9.0.52/logs divtomcat:1.0
[root@iZwz99osrzvcx9zd72bqslZ tomcat]# docker exec -it 0d12bb8348533 /bin/bash
5、访问测试http://119.23.109.216:9090/
6、发布项目（由于做了卷挂载，我们直接在本地编写项目就可以发布）
[root@iZwz99osrzvcx9zd72bqslZ test]# mkdir WEB-INF
[root@iZwz99osrzvcx9zd72bqslZ test]# ls
WEB-INF
[root@iZwz99osrzvcx9zd72bqslZ test]# cd WEB-INF/
[root@iZwz99osrzvcx9zd72bqslZ WEB-INF]# vim web.xml
xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
</web-app>
jsp
vim index.jsp
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8"/>
<title>title</title>
</head>
<body>
<h1>HTML</h1>
<p>Hello World！</p>
</body>
</html>
7. 发布自己的镜像到Docker Hub
1、https://hub.docker.com/ DockerHub官网进行注册
2、在服务器上提交自己的镜像
[root@iZwz99osrzvcx9zd72bqslZ tomcat]# 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
3、登陆成功后，docker push 推送
[root@iZwz99osrzvcx9zd72bqslZ tomcat]# docker login -u ghc990408
Password:
WARNING! Your password will be stored unencrypted in /root/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store
Login Succeeded
[root@iZwz99osrzvcx9zd72bqslZ tomcat]# docker push ghc/divtomcat:1.0
8. 发布镜像到阿里云
1、登录阿里云
2、找到容器镜像服务
3、创建个人实例
4、创建命名空间（为了隔离，防止冲突）
5、创建镜像仓库
6、浏览页面信息
四、Docker网络
1. 理解Docker
ip addr
三个网络
问题：docker是如何处理容器网络访问的？
# 测试
[root@iZwz99osrzvcx9zd72bqslZ /]# docker run -d -P --name tomcat10 tomcat
# 查看容器内部网络地址
[root@iZwz99osrzvcx9zd72bqslZ /]# docker exec -it tomcat10 ip addr
[root@iZwz99osrzvcx9zd72bqslZ /]# docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' tomcat10
172.17.0.2
# 问题：linux能不能ping通容器内部
[root@iZwz99osrzvcx9zd72bqslZ /]# ping 172.17.0.2
PING 172.17.0.2 (172.17.0.2) 56(84) bytes of data.
...
# 可以ping通
原理
1、我们每启动一个docker容器，docker就会给docker容器分配一个ip，只要安装了docker，就会有一个网卡 docker0
桥接模式，使用的技术是 evth-pair 技术
再次测试 ip addr ，发现多了一个网卡
2、在启动一个容器测试
我们发现这些容器带来的网卡，都是一对对的，这就是 evth-pair 技术
evth-pair 就是一堆的虚拟设备接口，他们都是成对出现的，一端连接协议，一端彼此相连
正因为有这个特性，evth-pair 充当一个桥梁，连接各种虚拟网络设备
3、测试 tomcat10和tomcat20能不能ping通
[root@iZwz99osrzvcx9zd72bqslZ /]# docker exec -it tomcat20 ping 172.17.0.2
# 结论 容器之间是可以互相ping通的
结论：tomcat10和tomcat20 是公用一个路由器，docker0
所有的容器不指定网络的情况下，都是docker0路由的，docker会给我们的容器分配一个默认的可用IP
小结
Docker 使用的是Linux的桥接，宿主机是一个Docker容器的网桥 docker0
Docker中所有的网络接口都是虚拟的，虚拟的转发效率高
2. 容器互连–link
思考：我们编写了一个微服务，database url = ip：，项目不重启，数据库ip换掉了，我们希望可以处理这个问题，可以用名字来进行访问容器？
# 启动01 02
[root@iZwz99osrzvcx9zd72bqslZ ~]# docker run -d -P --name tomcat01 tomcat
[root@iZwz99osrzvcx9zd72bqslZ ~]# docker run -d -P --name tomcat02 tomcat
[root@iZwz99osrzvcx9zd72bqslZ ~]# docker exec -it tomcat02 ping tomcat01
Error: No such container: tomcat02
# 不通
# 启动03使用 --link 连02
[root@iZwz99osrzvcx9zd72bqslZ ~]# docker run -d -P --name tomcat03 --link toncat02 tomcat
3979bd1c32b8a1f41c69b9366680c2829bc9065d793c13275382cef36f42ada7
[root@iZwz99osrzvcx9zd72bqslZ ~]# docker exec -it tomcat03 ping tomcat02
# 通
通过 --link 可以解决网络连通问题
3 ping 2 可以通，2 ping 3不能
反向不可以连通
探究：
[root@iZwz99osrzvcx9zd72bqslZ ~]# docker network ls
NETWORK ID NAME DRIVER SCOPE
af3b6a06129c bridge bridge local
d6e5b10748aa host host local
96ff2262067e none null local
[root@iZwz99osrzvcx9zd72bqslZ ~]# docker network inspect af3b6a06129c
其实 03 就是在本地配置了02的配置
# 查看hosts配置
[root@iZwz99osrzvcx9zd72bqslZ ~]# docker exec -it tomcat03 cat /etc/hosts
127.0.0.1 localhost
::1 localhost ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
172.17.0.3 toncat02 21f9d935d114
172.17.0.5 3979bd1c32b8
本质：--link 就是我们在hosts配置中增加了一个 172.17.0.3 toncat02 21f9d935d114 的映射。
我们现在玩docker已经不建议使用–link了。我们需要的是自定义网络，不使用docker0，docker0不支持容器名连接访问
3. 自定义网络
查看所有的docker网络
网络模式：
bridge：桥接（默认，自定义也使用bridge模式）
none：不配置网络
host：主机模式，和宿主机共享网络
container：容器内网络连通（不建议使用！局限性很大）
测试：
# 我们直接启动命令， 默认--net bridge，就是docker0
[root@iZwz99osrzvcx9zd72bqslZ ~]# 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
[root@iZwz99osrzvcx9zd72bqslZ ~]# docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
dfaeebb747264ad4570323cc57b140591f8c186497ce7f30e340d18a21d9c687
[root@iZwz99osrzvcx9zd72bqslZ ~]# docker network ls
NETWORK ID NAME DRIVER SCOPE
af3b6a06129c bridge bridge local
d6e5b10748aa host host local
dfaeebb74726 mynet bridge local # 自定义网络
96ff2262067e none null local
自己的网络已经创建好了
启动容器测试：
[root@iZwz99osrzvcx9zd72bqslZ ~]# docker run -d -P --name tomcat-net-01 --net mynet tomcat
24ac234b324911d8a8e0b1e20b3933d2ac1c28fd5b189ebeddba7152693bcc76
[root@iZwz99osrzvcx9zd72bqslZ ~]# docker run -d -P --name tomcat-net-02 --net mynet tomcat
5a7de0c3ac54b4072864fc053be8f1df9977519a1cd745b84770b2ecd22efa51
测试ping：
[root@iZwz99osrzvcx9zd72bqslZ ~]# docker exec -it tomcat-net-01 ping tomcat-net-02
# 可以ping通
我们自定义的网络docker都已经帮我们维护好了对应的关系。
好处：
不同的集群使用不同的网络，保证集群是安全和健康的
4. 网络连通
测试打通 tomcat01 —> mynet
[root@iZwz99osrzvcx9zd72bqslZ ~]# docker network connect mynet tomcat01
# 连通之后，就是把tomcat01放到了mynet下
# 一个容器，两个ip地址
# 测试ping
[root@iZwz99osrzvcx9zd72bqslZ ~]# docker exec -it tomcat01 ping tomcat-net-01
# 通
[root@iZwz99osrzvcx9zd72bqslZ ~]# docker exec -it tomcat02 ping tomcat-net-01
#不通，02还没打通
**结论：**假设要跨网络操作别人，就需要 docker network connect连通！
5. Redis集群部署实战
shell脚本
# 创建网卡
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
prot 6379
bind 0.0.0.0
cluster-enabled yes
cluster-config-file nodes.conf
cluster-announce-ip 172.38.0.1${port}
cluster-announce-port 6379
cluster-announce-bus-poet 16379
appendonly yes
EOF
done
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 6372:6379 -p 16371: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.11 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
......
# 进入
[root@iZwz99osrzvcx9zd72bqslZ ~]# docker exec -it redis-1 /bin/sh
# 配置集群
/data # redis-cli --cluster create 172.38.0.11:6379 72.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
......
# 查看并设值
/data # redis-cli -c
127.0.0.1:6379> cluster info
...
127.0.0.1:6379> set a b
> 输出redis-3在运行
# 关闭redis-3
[root@iZwz99osrzvcx9zd72bqslZ ~]# docker stop redis-3
# get
127.0.0.1:6379> get a
> 在redis-4 get到了值，因为4是3的从机
b
6. SpringBoot微服务打包Docker镜像
1、构建springboot项目
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class HelloController {
@RequestMapping("/hello")
public String hello(){
return "hello";
}
}
2、打包应用
package
3、编写DockerFile
FROM java:8
COPY *.jar /app.jar
CMD ["--server.port=8080"]
EXPOSE 8080
ENTRYPOINT ["java","-jar","/app.jar"]
4、构建镜像
5、发布应用
上传jar包和dockerfile
[root@iZwz99osrzvcx9zd72bqslZ home]# cd idea/
[root@iZwz99osrzvcx9zd72bqslZ idea]# ls
demo1-0.0.1-SNAPSHOT.jar Dockerfile
[root@iZwz99osrzvcx9zd72bqslZ idea]# docker build -t ideatest .
...
[root@iZwz99osrzvcx9zd72bqslZ idea]# docker run -d -P --name ghc-springboot0web ideatest
[root@iZwz99osrzvcx9zd72bqslZ idea]# docker ps
[root@iZwz99osrzvcx9zd72bqslZ idea]# curl localhost:32779
[xxxxxxx]# curel locathost:32779/hello
使用Docker之后，给别人交付就是一个镜像即可
扫一扫
393
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
