Docker超详细解析【从入门到深入】_docker详解
1.Docker概述
1.1Docker为什么会出现？
Docker相当于轻量级的虚拟机，但是别把它当作虚拟机用
一款产品：开发--上线 两套环境！ 应用环境，应用配置！
开发 ---运维，问题：我在我电脑上可以运行，版本更新，导致服务器不可用！对运维来说，考验十分大。
环境配置是十分的麻烦，每一个机器都要部署环境（集群Redis,ES,Hadoop....）!
发布一个项目（jar + (Redis MySQL jdk ES)），项目能不能带上环境打包！
Java --jar（环境:jdk,mysql,redis,es）配置麻烦，不能跨平台（项目通过java可以跨平台，其他不一定能跨平台）
---打包项目带上环境（镜像） ---（Docker仓库：商店） ---下载我们发布的镜像，直接运行即可！
Java --apk -------------------------------------------------发布（应用商店） --张三使用apk --安装即可！
Java --jar(环境)--打包项目带上环境（镜像）--Docker仓库，类似应用商店
Docker给以上问题，提出了解决方案！
Docker的想想来自于集装箱！
JRE --多个应用 （端口冲突）
隔离： Docker核心思想！ 打包装箱！ 每个箱子都是互相隔离的。
Docker通过隔离机制，可以将服务器利用到极致！
1.2Docker为什么这么火？
容器中技术出来之前，都是使用虚拟机技术
虚拟机也是属于虚拟化技术，Docker容器技术，也是一种虚拟化技术
十分轻巧
虚拟机：在window中安装一个Vmware ,通过这个软件我们可以虚拟出来一台或者多台电脑！笨重！
Vm, Linux centos原生镜像（一个电脑！） 隔离，需要开启多个虚拟机！ 几个G 几分钟启动
Docker,隔离，镜像（最核心的环境 4M +jdk +mysql）十分的小巧，运行镜像就可以了，秒级启动
文档地址：Docker Docs
仓库地址：https://hub.docker.com/ 远程仓库，APP商店
1.3Docker能干嘛
虚拟机技术的缺点：
- 资源占用十分多
- 冗余步骤多
- 启动很慢！
容器化技术
容器化技术不是模拟一个完整的操作系统
虚拟机 docker
比较Docker和虚拟机技术的不同
*传统虚拟机，虚拟出一个硬件，运行一个完整的操作系统，然后在这个系统上安装和运行软件
*容器内的应用直接运行在宿主机的内核，容器是没有自己的内核，也没有虚拟我们的硬件，所以就轻便了
*每个容器间都是互相隔离的，每个容器内都有一个属于自己的文件系统，互补影响。
DevOps（开发，运维）
更快速的交付和部署
传统：一堆帮助文档，安装程序
Docker:打包镜像，发布测试，一键运行
更便捷的升级和扩缩容
使用了Docker之后，我们部署应用就和搭积木一样！
更简单的系统运维
在容器化之后，我们的开发，测试环境高度一致。
更高效的计算资源利用
Docker是内核级别的虚拟化，可以在一个物理机上运行很多的容器实例！服务器性能最大化利用。
2.Docker 安装
2.1Docker的基本组成
客户端-服务器-仓库
镜像（image）:--apk安装包
docker镜像就好比是一个模板，可以通过这个模板来创建容器服务，tomcat镜像 ===> run ===> tomcat01容器（提供服务器），通过这个镜像可以创建多个容器（最终服务运行或者项目运行就是在容器中的）。
容器（container）:--应用
Docker利用 容器技术，独立运行一个或者一个组应用，通过镜像来创建的
启动，停止，删除，基本命令！
目前可以把这个容器理解为一个简易的linux系统
仓库（repository）--应用商店
仓库就是存放镜像的地方！
仓库分为公有仓库和私有仓库
Docker Hub(默认是国外的)
阿里云..都有容器服务器（配置镜像加速！）
2.2安装Docker
环境查看
# uname -r
# cat /etc/os-release
帮助文档：
- 卸载旧版本
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://download.docker.com/linux/centos/docker-ce.repo
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
#更新软件包的索引
yum makecache fast
4.安装docker相关的内容 docker-ce社区 ee企业版
yum install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
5.启动docker
systemctl start cocker
6.dokcer version 查看是否安装成功
7.hello-world
docker run hello-world
8.查看下载的hello-world镜像
docker images
#卸载docker
yum remove docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-ce-rootless-extras
rm -rf /var/lib/docker
rm -rf /var/lib/containerd
回顾hello-world流程
底层原理
docker是怎么工作的
Docker 是一个Client-Server结果的系统，Docker的守护进程运行在主机上。通过Sokcet从客户端访问！
DockerServer接收到Docker-Clinet的指令，就会执行这个命令！
Docker为什么比VM快
- Docker有着比虚拟机更少的抽象层
- Docker利用的数宿主机的内核，vm需要时Guest OS.
所以说，新建一个容器时候，docker不需要像虚拟机一样重新加载一个操作系统内核，避免引导。虚拟机是加载Guest OS，分钟级别的。而dockers是利用宿主机的操作系统，省略了复杂的过程，秒级！！
虚拟化技术分全虚拟，半虚拟，容器技术三大类
LXC是Linux Container。和docker一样是容器技术
3.Docker 命令
docker version #显示docker版本信息
docker info #x显示docker的系统信息，包括镜像和容器的数量
docker --help
帮助文档的地址：Reference | Docker Docs
3.1镜像命令
docker images #查看本机镜像
docker search搜索镜像
docker pull下载镜像
docker rmi 删除镜像
docker rmi -f 容器ID #删除指定镜像
docker rmi -f $(docker images -aq) #删除全部镜像
3.2 容器命令
说明：有了镜像我们才可以创建容器。Linux,下载一个centos镜像来测试学习
dokcer pull centos
新建容器并启动
列出所有的运行容器
退出容器
exit #直接容器停止并退出
Ctrl + P +Q #容器不停止退出
删除容器
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 #强制停止当前容器
3.3 常用命令
3.3.1后台启动容器
#命令 docker run [可选的参数] 镜像名！
# docker run -d centos
#问题docker ps，发现centos停止了
#常见的坑 docker 容器使用后台运行，就必须要有一个前台进程，docker发现没有应用，就会自动停止
#nginx,容器启动，发现自己没有提供服务，就会立刻停止，就是没有程序了
#nginxd,容器启动，发现自己没有提供服务，就会立刻停止，就是没有程序了
doc
3.3.2查看日志
#命令 docker logs -f -t --tail num 容器ID
#自己编写一段shell脚本
#docker run -d centos /bin/sh -c “while true; do echo kuangshen;sleep 1;done”
#显示日志
-tf #显示日志
--tail number #显示日志条数
3.3.3查看容器中进程信息 ps
#命令 docker top 容器ID
pid 是进程id ;ppid是父id
3.3.4查看镜像的元数据
#命令 docker inspect容器ID
3.3.5进入当前正在运行的容器
#我们通常容器都是后台方式运行的，需要进入容器，修改一些配置
#命令 docker exec -it 容器ID /bin/bash
#命令 docker attach 容器ID
#docker exec #进入容器后开启一个新的终端，可以在里面操作（常用）
#docker attach #进入容器正在执行的终端，不会启动新的进程
3.3.6将文件从容器中拷出
在容器内新建一个文件
#命令 touch test.java
将文件从容器中拷到主机上
#命令 docker cp 容器ID:/文件路径/文件名 /拷贝到的目标路径
例：docker cp b78453025116:/home/test.java /home/
#拷贝是一个手动过程，未来我们使用 -v 卷技术
3.3.7小结
4 部署
4.1部署Nginx
1.搜索镜像
docker search nginx
2.下载镜像
docker pull nginx
3.查看镜像
docker images
4.运行
docker run -d --name nginx01 -p 3344:80 nginx
5.测试
rurl localhost:3344
6.端口暴露的概念
思考问题：我们每次改动nginx配置文件，都需要进入容器内部？十分麻烦，是否可以在容器外部提供一个映射路径，达到在容器外修改文件，容器内就可以自动修改？-v 数据卷。。
4.2部署Tomcat
官方使用文档：
docker run -it --rm tomcat:9.0
#之前启动的都是后台，停止容器之后，容器还是可以查到，docker run -it --rm 一般用来测试，用完就删除了
#下载在启动
docker pull tomcat
#启动运行
docker run -d -p 3355:8080 --name tomcat01 tomcat
#测试访问404
#进入容器
docker exec -it tomcat01 /bin/bash
#发现问题
1.linux命令少了。2.没有webapps
原因：
1.阿里云镜像的原因：默认是下载最小的镜像，所有不必要的都剔除掉
2.保证最小的可运行环境
思考问题：我们以后部署项目，每次都要进入容器？是否可以在容器外部提供一个映射路径，webapps,我们在外部放置项目，就自动同步到内部就好了！
4.3部署ES+kibana
#es 暴露的端口很多！
#es 十分小号内存
#es 的数据一般需要放置到安全目录！！挂载
# -- net somenetwork ?网络配置
1.启动elasticsearch
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e “discover.type=single-node” elasticsearch:7.6.2
2.启动了，linux就卡住了， docker stats查看cpu状态
3.关闭，增加内存的限制 修改配置文件 -e环境配置修改
docker run -d --name elasticsearch02 -p 9200:9200 -p 9300:9300 -e “discover.type=single-node” -e ES_JAVA_OPTS=”-Xms64m -Xmx512m” elasticsearch:7.6.2
4.查看docker stats
使用kibana连接es
5. 可视化工具
1.portainer(先用这个)
docker run -d -p 8088:9000 \\ --restart=always -v /var/run/docker.socek:/var/run/docker.sock --privileged=true portainer/portainer
2.Rancher(CI/CD再用)
什么是portainer?
docker 图形化界面管理工具！提供一个后台面板供我们操作！
docker run -d -p 8088:9000 \\ --restart=always -v /var/run/docker.socek:/var/run/docker.sock --privileged=true portainer/portainer
测试访问：http://Ip:8088/
进入之后的面板
6. Docker 镜像
6.1镜像是什么
镜像是一种轻量级，可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件，它包含某个软件所需的所有容器，包含代码，运行时，库，环境变量和配置文件。
所有的应用，直接打包docker镜像，就可以直接跑起来！
如何得到镜像：
*从远程仓库下载
*朋友拷贝给你
*自己制作一个镜像DockerFile
6.2Docker镜像加载原理
UnionFS(联合文件系统)
我们下载的时候看到的一层层就是这个！
UnionFs(联合文件系统),Union文件系统（UnionFS）是一种分层，轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层叠加，同时可以将不同目录挂载到同一个虚拟文件系统下。Union文件系统使Docker镜像的基础。镜像可以通过分层来进行继承，基于基础镜像的（没有父镜像），可以制作各种具体的应用镜像。
特性：一次同时加载多个文件系统，但从外面看来，只能是一个文件系统。联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录。
例：tomcat和mysql都需要centos，直接从已有的一方拿过去即可。
容器是隔离的，不关镜像的事。
镜像是分层的，容器是隔离的。
Docker镜像加载原理
docker的镜像实际上是由一层一层文件系统组成的，这种层级的文件系统UnionFS.
bootfs(boot file system)主要是包含BootLoader和Kernel，BootLoader主要是引导加载kernel,Linux刚启动回家再bootfs文件系统，在Docker镜像的最底层是bootfs,这一层与我们典型的Linux/Unix系统是一样的，包含boot加载器和内核，当boot加载完成之后整个内核就都在内存中了，此时内存的使用权由bootfs转交给内核，系统也会卸载bootfs.
Rootfs,在bootfs之上，包含的就是典型的Linux系统中的/dev,/proc,/bin,/etc等目标目录和文件。Rootfs就是各种不同操作系统发行版，比如Ubuntu，Centos等。
平时我们安装虚拟机的Centos都是好几个G,为什么Dokcer才200M？
对于一个精简的OS,rootfs可以很小，只需要包含最基本的命令，工具和程序库就行。因为底层直接用主机的Kernel,自己只需要提供rootfs就可以了，由此可见，对不同linux发行版，bootfs基本是一致的，rootfs会有差别，因此不同发行版可以公用bootfs。
镜像分层理解
我们下载一个镜像，看到日志输出，可以看到是一层层的在下载
思考：为什么docker镜像采用这种分层的结构？
最大的好处：莫过于资源共享!比如多个镜像都从相同的Base镜像构建而来，那么宿主机只需要在磁盘保留一份base镜像，同时内存中也只需要加载一份base镜像，这样就可以为所有的容器服务了，而且镜像的每一层都可以被共享。
查看镜像分层的方式：docker image inspect redis:latest
理解：
所有的docker镜像都起始于一个基础镜像层，当进行修改或增加新的内容们就会在当前镜像层之上，创建新的镜像层。
例如：Ubuntu Linux 16.04创建一个新的镜像，这就是新镜像的第一层，如果在该镜像中添加Python包，就会在基础镜像层之上创建第二个镜像，如果继续添加一个安全补丁，就会创建第三个镜像层
在添加额外的镜像层的同时，镜像始终保持是当前所有镜像的组合
这种情况下，上层镜像中的文件覆盖了底层镜像中的文件，这样就使得文件的更新版本作为一个新镜像层添加到镜像当中。
Docker通过存储引擎（新版采用快照机制的方式）来实现镜像层堆栈，并保证镜像层对外展示为统一的文件系统。
Linux上可用的存储引擎有AUFS,OVerlay2,Device Mapper,Btrfs以及ZFS,顾名思义，每种存储引擎都基于Linux中对应的文件系统或者块设备技术，并且每种引擎都有其独特的性能特点
Docker在windows上仅支持windowsfilter一种存储引擎，该引擎基于NTFS文件系统之上实现了分层和CoW.下面展示了与系统显示的三层镜像。所有镜像层堆叠并合并，对外提供统一的视图。
特点：
Docker镜像都是只读的，当容器启动后，一个新的可写层被加载到镜像的顶部！
这一层就是我们通常说的容器层，容器之下的都叫镜像层！
如何提交一个自己的镜像
Commit镜像
docker commit 提交容器成为一个新的副本
docker commit -m=”提交的描述信息” -a=”作者” 容器ID 目标镜像名:[tag]
实战测试
1.启动一个默认的tomcat
2.发现这个默认的tomcat 是没有webapps，镜像的原因，官方的镜像默认webapps是没有文件的
3.自己考进去了基本的文件
4.将我们操作过的容器通过commit提交作为一个镜像，我们以后就使用我们修改过得镜像即可，这就是我们自己的一个修改的镜像
如果你想要保存当前容器的状态，就可以通过commit来提交，获得一个镜像
就好比我们以前学习vm时候 快照。
7.容器数据卷
什么是容器数据卷
Docker的理念回顾
将应用和环境打包成一个镜像！
数据？如果数据在容器中，那么我们容器删除，数据就会丢失！需求：数据可以持久化
MySQL，容器删了，数据也没了。需求：MySQL数据可以存储在本地！
容器之间可以有一个数据共享的技术！Docker容器中产生的数据，可以同步到本地！
这就是卷技术！目录挂载，将我们容器内的目录，挂载到Linux上面！
总结：容器的持久化和同步操作！容器间也是可以数据共享的！
使用数据卷
方式一：使用命令来挂载 -v
docker run -it -v 主机目录:容器内目录
#测试：docker run -it -v /home/cheshi:/home centos /bin/bash
#启动起来之后，可以使用docker inspect 容器ID 查看挂载情况
测试文件的同步
停止容器
宿主机上修改文件
容器启动
容器内部的数据依旧是同步的
好处：我们以后修改只需要在本地修改即可，容器内会自动同步！
实战：安装MySQL！
思考：MySQL的数据持久化问题
#获取镜像
docker search mysql
docker pull mysql:5.7
#运行容器，需要做的数据挂载！#安装启动mysql，需要配置密码，
#官方测试：docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag
#启动我们的mysql
-d 后台运行
-p 端口映射
-v 卷挂载
-e 环境配置
--name 容器名字
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 mysql mysql:5.7
#启动成功之后，我们在本地使用sqlyog来连接测试一下
#sqlyog-连接到服务器的3310 ---3310和容器内的3306映射，这个时候我们就可以连接上了！
#在本地测试创建一个数据库，查看下我们映射的路径是否ok!
我们将容器删除。
发现，我们挂载到本地的数据卷依旧没有丢失，这就实现了容器数据的持久化
具名和匿名挂载
#匿名挂载
-v 容器路径！
docker run -d -P --name -v /etc/nginx nginx
#查看所有volume的情况
docker volume ls
#这里发现，这种挂载就是匿名挂载 我们在-v 后只写了容器内的路径，没写容器外的路径
#具名挂载
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx
docker volume ls
#通过-v 卷名：容器内路径
#查看一下这个卷
所有docker容器内的卷，没有指定目录的情况下都是在 /var/lib.docker/volumes/xxx/_data
我们通过具名挂载可以方便的找到我们的一个卷，大多情况下使用 具名挂载
如何确定是具名挂载还是指定路径挂载！
-v 容器内的路径 #匿名挂载
-v 卷名:容器内的路径： #具名挂载
-v /宿主机路径:容器内的路径 #指定路径挂载
两类：1:指定目录挂载，2:匿名和具名这俩都不指定路径
拓展：
通过 -v 容器内的路径: ro rw 改变读写权限
ro readonly 只读
rw readwrite 读写
一旦设置了容器权限，容器对我们挂载出来的内容就有限定了
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 说明这个路径只能通过宿主机来操作，容器内部无法操作！
挂载方式二：Dockerfile就是用来构建docker镜像的构建文件！命令脚本！
通过这个脚本可以生成镜像。镜像是一层一层的，脚本一个个的命令。每个命令都是一层！
#创建一个dockerfile文件。 名字可以随意 建议 dockerfile
#文件中的内容 指令（大写） 参数
FROM centos
VOLUME [“volume01” , “volume02”]
CMD echo “----end---”
CMD /bin/bash
#这里的每个命令，就是镜像的一层！
启动下自己的容器
这个卷和外部一定有一个相同的目录
查看一下卷挂载的路径
测试一下刚才的文件是否同步出去了！
这种方式我们未来使用的十分多，因为我们通常会构建自己的镜像！
假设构建镜像的时候没有挂载，手动镜像挂载 -v 卷名:/容器内路径
数据卷容器
多个mysql同步数据！
#启动3个容器 通过我们自己写的镜像启动
docker run -it --name docker02 --volumes-from docker01 kuangshen/centos:1.0
Docker run -it --name docker03 --volumes-from docker01 kuangsheng/centos:1.0
#删除docker01,查看docker02,docker03数据还是存在
多个mysql、redis实现数据共享
# 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 3311:3306 -e MYSQL_ROOT_PASSWORD=123456 --name mysql02
volume-from mysql01 mysql:5.7
#这个时候，可以实现两个容器的数据同步
结论：
容器之间配置信息的传递，数据卷容器的生命周期一直持续到没有容器使用为止
但是一旦你持久化到本地（父容器挂载到宿主机），这个时候，本地的数据不会删除！
8DockerFile
8.1 DockerFile介绍
dockerfile是用来构建docker镜像的文件！即：命令参数脚本
构建步骤：
- 编写一个dockerfile文件
- docker build构建成为一个镜像
- docker run 运行镜像
- docker pull 发布镜像（DockerHub，阿里云镜像）
查看一下官方是怎么做的
很多官方的镜像都是基础包，很多功能都是没有的，我们通常会自己搭建自己的镜像！
8.2 DockerFile构建过程
基础知识：
- 每个保留关键字（指令）都必须是大写字母
- 执行从上到下顺序
- #表示注释
- 每一个指令都会创建提交一个新的镜像层，并提交
dockerfile是面向开发的，我们以后发布项目，做镜像，就需要编写dockerfile文件，这个文件十分简单！
1.开发，部署，运维。。
Docker镜像逐渐成为企业交付的标准，必须掌握！
DockerFile:构建文件，定义一切步骤，源代码
DockerImages:通过DockerFIle构建生成的镜像，最终发布和运行的产品
Docker容器：容器就是镜像运行起来提供的服务
DockerFile的指令
FROM #基础镜像，一切从这里开始构建
MAINTAINER #镜像是谁写的，姓名+邮箱
RUN #镜像构建的时候需要运行的命令
ADD #步骤：tomcat镜像 这个Tomcat压缩包！添加内容
WORKDIR #镜像的工作目录
VOLUME #挂载的目录
EXPOSE #暴露端口配置 -p
CMD #指定这个容器启动的时候要运行的命令,只有最后一个会生效，可被替代
ENTRYPOINT #指定这个容器启动的时候要运行的命令,可以追加命令
ONBUILD #当构建一个被继承DockerFile 这个时候就会运行ONBUILD的指令，触发指令
COPY #类似ADD 将文件拷贝到镜像中
ENV #构建的时候设置环境变量！
实战测试
Docker Hub中99%的镜像都是从这个基础镜像过来的FROM scratch,然后配置需要的软件和配置来进行构建
创建一个自己的Centos
1.编写DockerFIle文件
FROM centos
MAINTAINER lxj
ENV MYPATH /usr/local
WORKDIR $MYPATH
RUN yum -y install vim
RUN yun -y install net-tools
EXPOSE 80
CMD echo $MYPATH
CMD echo “----end---”
CMD /bin/bash
2.通过这个文件构建镜像
#命令： docker build -f dockerfile文件路径 -t 镜像:[tag]
对比之前得centos
我们增加之后的镜像
可以通过docker history 研究一个镜像是怎么做的。 --no-trunc这个参数显示完成信息。
CMD和ENTRYPOINT的区别
CMD #指定这个容器启动的时候要运行的命令,只有最后一个会生效，可被替代
ENTRYPOINT #指定这个容器启动的时候要运行的命令,可以追加命令
测试CMD命令
测试ENTRYPOINT命令
实战：Tomcat镜像
1.准备镜像文件 tomcat压缩包，jdk的压缩包！
2.编写dockerFile文件 官方命名Dockerfile ,build会自动寻找这个文件，就不需要 -f 指定!
FROM centos
MAINTAINER linxingjie
COPY readme.txt /usr/local/readme.txt
#ADD命令会自动解压
ADD jdk-8ull-linux-x64.tar.gz /usr/loacl/
ADD apache-tomcat-9.0.22.tar.gz /usr/loacl/
RUN yum -y install vim
ENV MYPATH /usr/local
WORKDIR $MYPATH
ENV JAVA_HOME /usr/local/jdk1.8.0_11
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/bin
EXPOSE 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 . #Dockerfile 是官方名字 不用-f指定了
4.启动镜像
docker run -d
-p 9090:8080
--name linxjTomcat
-v /home/kuangshen/build/tomcat/test:/usr/local/apache-tomcat-9.0.22/webapps/test
-v /home/kuangshen/build/tomcat/tomcatlogs:/usr/local/apache-tomcat-9.0.22/logs
diyTomcat
5.发布项目（由于做了卷挂载，我们直接在本地编写项目就可以发布了!）
挂载的test文件夹下，新建WEB-INF文件，在WEB-INF文件夹下放置web.xml
在test文件夹下新建一个index.jsp(index.html)
6.访问测试
外部访问9090端口
我们以后的开发步骤：需要掌握dockerFile的编写！我们之后的一切都可以使用docker镜像来发布运行！！
发布自己的镜像
发布到DockerHub
提交的时候一直也是按照镜像的层级来提交的！
发布到阿里云的服务器上
小结
9.Docker网络原理
原理
1.我们每启动一个docker容器，docker就会给docker容器分配一个ip,我们只要安装了docker,就会有一个网卡，docker0桥接模式，使用的技术是evth-pair技术！
再次测试ip addr
2.再启动一个容器，我们发现又多了一对网卡（宿主机263，容器内部264）
# 我们发现这个容器带来的网卡，都是一对对的
# Evth-pair 就是一对的虚拟设备接口，他们都是成对出现的，一段连接协议，一段彼此相连
# 正因为这个特性，evth-pair充当一个桥梁，连接各种虚拟网络设备的
# OpenStac，Docker容器之间的连接，OVS的连接，都是使用evth-pair技术
3.我们测试tomcat01和tomcat02是否可以ping通
docker exec -it tomcat02 ping 172.18.0.2
绘制网络连接图
结论：tomcat01和tomcat02是公用的一个路由器 docker0
所有的容器不指定网络的情况下，都是docker0路由的，docker会给我们的容器分配一个默认的可用IP
小结
Docker使用的是Linux的桥接，宿主机中是一个Dokcer容器的网桥 docker0.
Docker内的所有网络接口都是虚拟的。虚拟的转发效率高！（内网传递文件！）
只要容器删除，对应的网桥一对就没了！
--LInk
思考一个场景，我们编写了一个微服务，database url =ip 。项目不要重启，数据库ip换掉了我们希望可以处理这个问题。可以通过名字来进行访问容器
自定义网络
创建两个容器使用自己搭建的网络
docker run -d -P --name tomcat-net-01 --net mynet tomcat
docker run -d -P --name tomcat-net-02 --net mynet tomcat
网络联通
测试打通 tomcat01 --mynet
Docker network connect mynet tomcat01
联通之后就是将tomcat01 放到mynet网络下？
一个容器两个Ip地址！！
#列子：阿里云服务，公网IP 私网IP
10.实战：Redis集群部署
Docker搭建redis集群完成！
11.IDEA整合Docker
1.构架springboot项目
2.打包应用
3.编写dockerfile
4.构建镜像
5.发布运行
