Docker 为什么出现？
一款产品：开发–上线 两套环境！应用环境，应用配置！
传统：开发jar，运维来做！
现在：开发打包部署上线，一套流程做完！
java – apk – 发布(应用商店) – 张三使用apl – 安装即可用！
java – jar(环境) – 打包项目带上环境(镜像) – (Docker仓库：商店) – 下载发布的镜像 – 直接运行即可！
Docker 解决方案：
Docker通过隔离机制，可以将服务器利用到极致！
隔离机制：多个应用之间都是相互隔离的，无关联，不会互相影响。
VM(虚拟机) 与 Docker 比较：
VM：linux centos原生镜像(一个电脑！) 隔离，需要开启多个虚拟机 ，几个G！
Docker：隔离，镜像(最核心环境 4m + jdk + mysql ) 十分的小巧，运行镜像就可以了！小巧！几个M KB
Docker 介绍：
docker是基于 GO 语言开发的！开源项目！
官网：https://www.docker.com/
文档地址：https://docs.docker.com/ docker文档超级详细
仓库地址：https://hub.docker.com/ (跟 github 类似)
Docker 能干什么？
虚拟机技术缺点：
- 资源占用十分多
- 冗余步骤多
- 启动很慢
容器化技术：
容器化技术不是模拟的一个完整的操作系统。
比较 Docker 和 虚拟机技术的不同：
1. 传统虚拟机，虚拟出一条硬件，运行一个完整的操作系统，然后在这个系统上安装和运行软件
2. 容器内的应用直接运行在 宿主机 的内容，容器没有自己的内核，也没有虚拟硬件，所以更轻便
3. 每个容器间都是互相隔离，每个容器都有一个属于自己的文件系统，互不影响DevOps(开发、运维)：
应用更快速的交付和部署
传统：一堆帮助文档，安装程序
Docker：打包镜像发布测试，一键运行
更便捷的升级和扩缩容
使用了 Docker 之后，部署应用就和搭积木一样！
更简单的系统运维
在容器化之后，开发和测试环境都是高度一致的。
更高效的计算资源利用
Docker 是内核级别的虚拟化，可以在一个物理机上运行很多容器实例！服务器性能可以被压榨到极致！
Docker 安装：
Docker 的基本组成：
**镜像( image )：**docker镜像就好比是一个模板，可以通过这个模板来创建容器服务，tomcat镜像 -》 run -》 tomcat01 容器(提供服务器)，通过这个镜像可以创建多个容器(最终服务运行 或者项目运行就是在容器中的)。
**容器( container )：**Docker利用容器技术，独立运行一个或一个组应用，通过镜像来创建的。
启动，停止，删除，基本命令！
目前可以把这个容器理解为 是一个简易的 linux 系统
**仓库( repository)：**仓库就是存放镜像的地方！仓库分为共有仓库和私有仓库！
Docker Hub(默认是国外的)，阿里云…都有容器服务器(需配置镜像加速器下载！)
Docker 安装：
- 卸载旧版本：
yum remove docker \
docker-client \
docker-client-latest \
docker-common \
docker-latest \
docker-latest-logrotate \
docker-logrotate \
docker-engine- 需要的安装包：
yum install -y yum-utils- 设置镜像仓库：
默认是国外的：
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 软件包索引
yum makecache fast
- 安装 docker docker-ce社区 ee 企业版
yum install docker-ce docker-ce-cli containerd.io
或
yum install docker-ce- 启动 docker
# 启动docker
# systemctl start docker
# 设置开机启动
# sudo systemctl enable docker
# 停止docker
# sudo systemctl stop docker- 使用 docker version 查看是否安装成功
- 通过运行图像验证 Docker 引擎是否正确安装(hello-world)
docker run hello-world- 查看一下下载的这个 hello-world 镜像
docker images- 了解卸载 docker
- 卸载依赖
yum remove docker-ce docker-ce-cli containerd.io- 删除资源
rm -rf /var/lib/docker
rm -rf /var/lib/containerd- 配置阿里云镜像加速(省略)
Docker 底层原理：
Docker是怎么工作的？
Docker 是一个 Client-Server 结构的系统，Docker的守护进程运行在主机上。通过Socket从客户端访问！DockerServer 接收到 Docker-Client 的指令，就会执行这个命令！
Docker 为什么比 VM 快？
- Docker 有着比 VM 更少的抽象层。
- docker 利用的是宿主机的内核，VM 需要时 Guest OS。
所以说，新建一个容器的时候，docker不需要像虚拟机一样重新加载一个操作系统内核，避免引导。虚拟机时加载Guest OS，分钟级别的！而 docker 是利用宿主机的操作系统，省略了这个过程，秒级！
Docker 的常用命令
帮助命令：
docker version #显示docker版本信息
docker info #显示docker的系统信息，包括镜像和容器的数量
docker 命令 --help #显示帮助命令 例如 docker info --help帮助文档地址：https://docs.docker.com/engine/reference/run/
镜像命令：
docker images 查看所有本地的主机上的镜像
# 解释
REPOSTORY 镜像的仓库源
TAG 镜像的标签
IMAGE ID 镜像的id
CREATED 镜像的创建时间
SIZE 镜像的大小
# 可选项
-a , --all # 列出所有镜像
-q , --quiet # 只显示镜像的iddocker search 搜索镜像
#docker search mysql
#docker search mysql --filter=stars=5000 #表示搜索量5000以上的应用docker pull 下载镜像
# 下载镜像 docker pull 镜像名[:tag]
# docker pull mysql #如果不写 tag(版本号)，默认就是 latest(最新版本)
#docker 下载 是 分层下载，docker imge的核心 联合文件系统
# docker pull mysql:5.7 #hiding版本下载
# docker pull mysql 等价于 docker pull docker.io/library/mysql:lastestdocker rmi 删除镜像！
# docker rmi -f 镜像id # 删除指定的镜像
# docker rmi -f 镜像id 镜像id 镜像id # 删除多个镜像
# docker rmi -f $(docker images -aq) # 删除全部的镜像容器命令：
说明：我们有了镜像才可以创建容器，linux，下载一个 centos 镜像来测试学习
docker pull centos新建容器并启动
docker run [可选参数] image
#参数说明
--name='Name' 容器名字 例如：tomcat01 tomcat02 ，用来区分容器
-d 后台方式运行
-it 使用交互方式运行，进入容器查看内容
-p 指定容器的端口 -p 8080:8080
-P 随机指定端口# 测试，启动并进入容器
docker run -it centos /bin/bash #内部容器跟外部容器无关联
# 从容器中退回主机
exit列出所有的运行的容器：
docker ps # 列出当前正在运行的容器
docker ps -a #列出正在运行的 + 历史运行过的容器
docker ps -n=数字 #显示最近创建的容器
docker ps -aq #只显示容器的编号退出容器：
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 ps，发现 centos 停止了
# 常见的坑，docker 容器使用后台运行就必须要有一个前台进程，docker发现无应用，会自动停止
# nginx，容器启动后，发现自己没有提供服务，就会立刻停止，就是没有程序了查看日志：
docker logs -f -t --tail 容器id，没有日志
# 编写 shell 脚本循环启动
# docker run -d centos /bin/sh -c "while true;do echo Administrator;sleep 1;done"
# 显示日志
-tf # 显示日志
--tail number #显示日志条数，number 数字
# docker logs -tf --tail 10 35a813b9d2bc查看容器中进程信息：
# 命令 docker top 容器id
# docker top 33996f0cbde3查看镜像的元数据：
# docker inspect 容器id
docker inspect 33996f0cbde3进入当前正在运行的容器：
# 我们通常容器都是使用后台方式运行，需要进入容器，修改一些配置
# 命令一
docker exec -it 容器id bashshell
# 测试
# docker exec -it e1fec3a9b3f7 /bin/bash
# ps -ef # 显示全部进程
# 命令二
docker attach 容器id
# 测试
# docker attach 33996f0cbde3
# docker exec # 进入容器后开启一个新的终端，可以在里面操作（常用）
# docker attach # 进入容器正在执行的终端，不会启动新的进程从容器内拷贝文件到主机上：
docker cp 容器id:容器内路径 目的的主机路径
# 测试
# 进入容器内部
# docker exec -it e1fec3a9b3f7 /bin/bash
# 容器内创建文件
# touch test.java
# 拷贝到主机
# docker cp e1fec3a9b3f7:test.java /homeDocker 项目环境安装：
部署 Nginx ：
# 1、搜索镜像 docker search nginx (建议去dockerhub搜索,有帮助文档)
# 2、下载镜像 docker pull nginx
# 3、运行测试 docker images
# -d 后台运行
# --name 给容器命名
# -p 宿主机端口，容器内部端口
# docker run -d --name nginx01 -p 3344:80 nginx
# docker ps
# curl localhost:3344(也可以在网页在宿主机进行测试 http://宿主机IP:3344/)
# 进入容器 docker exec -it nginx01 /bin/bash
# whereis nginx(查找nginx所在位置)部署Tomcat：
# 官方的使用
# docker run -it --rm tomcat:9.0
# 我们之前的启动都是后台，停止了容器之后，容器还是可以查到。 官方的命令 一般用来测试，用完即删除
# 下载再启动
# docker pull tomcat
# 启动运行
# docker run -d -p 3355:8080 --name tomcat01 tomcat
# 测试访问没有问题后
# 进入容器
# docker exec -it tomcat01 /bin/bash
# 将 webapps.list 文件夹文件拷贝进入 webapps
# cp -r webapps.dist/* webapps
# 发现问题：1.linux命令少了；2.没有webapps
# 原因：阿里云镜像的原因：默认是最小的镜像，所有不必要的都剔除掉。保证最小可运行的环境！部署ES(全文检索) + Kibana：
elasticsearch简写es，es是一个高扩展、开源的全文检索和分析引擎，它可以准实时地快速存储、搜索、分析海量的数据。
# es 暴露的端口很多
# es 十分耗内存
# es 的数据一般需要放置到安全目录！挂载
# --net somenetwork? 网络配置
# 启动 elasticsearch
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.6.2
# 启动了 linux就卡住了 docker stats 查看 cpu的状态
# Ctrl+C 退出查看CPU状态,因为状态是时刻刷新的
# es 是十分耗内存的，1.x G 一般系统 一核2G！
# 赶紧关闭，增加内存的限制，修改配置文件，-e 环境配置修改
docker run -d --name elasticsearch02 -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.6.2可视化：
portainer(先用这个)# docker run -d -p 8088:9000 --restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainerRancher(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
# 访问测试：http://ip:8088/
# 选择本地面板
# 平时不会用到，测试玩玩Docker镜像讲解：
镜像是什么？
镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件，它包含运行某个软件所需的所有内容，包括代码、运行时、库、环境变量和配置文件。
Docker镜像加载原理：
# UnionFS(联合文件系统)
UnionFS(联合文件系统)：Union文件系统(UnionFS)是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。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,/etc 等标准目录和文件。rootfs 就是各种不同的操作系统发行版，比如 Ubuntu，Centos等等。# docker
对于一个精简的 OS，rootfs 可以很小，只需要包含最基本的命令，工具和程序就可以了，因为底层直接用 Host 的 kernel，自己只需要提供 rootfs就可以了。由此可见对于不同的linux发行版，bootfs 基本是一致的，rootfs 会有差别，因此不同的发行版可以公用 bootfs。
# 所以 虚拟机是分钟级别，容器是秒级的！分层理解：
# 分层的镜像
# 我们去下载一个镜像，观察下载的日志输出，可以看到是一层一层在下载！
# Docker镜像这种分层结构最高的好处：资源共享
# 比如有多个镜像从相同的Base镜像构建而来，那么宿主机只需在磁盘上保留一份 base 镜像，同 时内存中也只需要加载一份base镜像，这样就可以为所有容器服务了，而且镜像的每一层都可以被 共享
# 查看镜像分层的方式可以通过 docker image inspect 命令！
# 例如： docker image inspect redis:tag(版本名称)
# 理解：
# 所有的 Docker镜像都起始于一个基础镜像层，当进行修改或增加新的内容时，就会在当前镜像层 之上创建新的镜像层。
# 例如：假如基于 Ubuntu Linux 16.04 创建一个新的镜像，这就是新镜像的第一层；如果在该 镜像中添加 Python 包，就会在基础镜像之上创建第二个镜像层；如果继续添加一个安全补丁，就 会创建第三个镜像层。# 特点
# Docker镜像都是只读的，当容器启动时，一个新的可写层被加载到镜像的顶部！
# 这一层就是我们通常说的容器层，容器之下的都叫镜像层！
# 容器层：你的所有操作都是基于容器层的commit 镜像：
# docker commit 提交容器成为一个新的副本
# 命令和git类似
# docker commit -m="提交的描述信息" -a="作者" 容器id 目标镜像名:[tag]# 实战测试
# 启动一个默认的tomcat，但是默认的tomcat没有webapps应用(没有启动访问页面)(镜像原因)
# 拷贝一个基本的文件然后提交镜像
# docker commit -a="tyx" -m="add webapps app" 2cb3afe58e1f tomcat02:1.0
# 以后就可以直接使用我们修改过的镜像！容器数据卷：
什么是容器数据卷？
需求：数据可以持久化！ 容器之间可以有一个数据共享的技术！
Docker容器产生的数据，同步到本地！这就是卷技术！目录的挂载，将我们容器内的目 录，挂载到Linux上面！
总结一句话：容器的持久化和同步操作！容器间可以数据共享！
使用数据卷：
# 方式一：直接使用命令来挂载 -v
# docker run -it -v 主机目录:容器内目录
# 测试
# docker run -it -v /home/ceshi:/home centos /bin/bash
# 启动起来后我们可以通过 docker inspect 容器id 查看挂载信息
# 在 "Mounts" 内查看挂载信息。
# 文件内容同样可以同步挂载！
# 停止容器 - 在宿主机修改文件 - 启动容器 - 容器内的数据依旧同步
# docker stop 容器id --停止容器
# docker start 容器id --启动容器
# docker attach 容器id --进入容器
# 好处：修改文件配置可以在宿主机修改，容器内自动同步！实战：Mysql：
# Mysql 的数据持久化问题
# 获取镜像
# docker pull mysql:5.7
# 运行容器，需要做数据挂载！ #安装启动 mysql，需要配置密码！
# 官方测试：
# docker run -name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret -pw -d mysql:tag
# 本机测试：
# -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 mysql01 mysql:5.7
# 启动成功后，在本地使用 SQLyog 连接测试，用户是root 密码是设置的密码
# SQLyog 连接到服务器的3310 ---3310和容器内的3306映射
# 在本机测试创建一个数据库，查看一下映射的路径是否有生成数据库！
# docker rm -f 容器名字 --删除容器
# 测试结果发现：即使删除了容器，数据也保留了下来！
# 这样就实现了数据的持久化！具名和匿名挂载：
# 匿名挂载
-v 容器内路径
docker run -d -P --name nginx-1 -v /etc/nginx nginx
# 查看所有的 volume(卷) 的情况
docker volume ls
# 如果在 -v 只写了容器内的路径，没有写容器外的路径 就是匿名挂载！
# 具名挂载
docker run -d -P --name nginx02 -v tyx-nginx:/etc/nginx nginx
# 通过 -v 卷名:容器内路径
# 查看卷
# docker volume inspect 卷名
# 所有的docker容器内的卷没有指定目录的情况下都在/var/lib/docker/volumes/xxx/_data
# 我们通过具名挂载可以方便找到我们一个卷，大多数情况在使用 具名挂载# 如何确定是 具名挂载 还是 匿名挂载，还是指定路径挂载！
-v 容器内路径 #匿名挂载
-v 卷名:容器内路径 #具名挂载
-v /宿主机路径:/容器内路径 #指定路径挂载# 拓展
# 通过 -v 容器内径路:ro/rw 改变读写权限
ro readonly #只读
rw readwrite #可读可写
# 一旦设置了容器权限，容器对我们挂载出来的内容就有限制
# docker run -d -P --name nginx02 -v tyx-nginx:/etc/nginx:ro nginx
# docker run -d -P --name nginx02 -v tyx-nginx:/etc/nginx:rw nginx
# 只有看到 ro 就说明这个路径只能通过宿主机来操作，容器内部无法操作！初识Dockerfile：
# Dockerfile 就是用来构建 docker 镜像的构建文件！
# 通过这个脚本可以生成镜像，镜像是一层一层的，脚本一个个的命令，每个命令都是一层！# 创建一个 dockerfile 文件，名字可以随机，建立 Dockerfile
# 文件中的内容 指令(大写) 参数
FROM centos
VOLUME ["volume01","volume02"]
CMD echo "----end----"
CMD /bin/bash
# 这里的每个命令，就是镜像的一层！ 注意最后要加空格+.
docker build -f /home/docker-test-volume/dockerfile1 -t tyx/centos:1.0 .
# 启动自己生成的镜像
# docker run -it 935391a2bb00 /bin/bash
# 假设构建镜像的时候没有挂载卷，要手动镜像挂载 -v 卷名:容器内路径 ！数据卷容器：
# 多个 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 3311: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 文件。
Docker 镜像逐渐成为企业交付的标准！
DockerFile：构建文件，定义了一切的步骤，源代码；
DockerImages：通过 DockerFile 构建生成的镜像，最终发布和运行的产品！
Docker 容器：容器就是镜像运行起来的服务器。
DockerFile 的指令：
FROM # 基础镜镜像，一切从这里开始构建
MAINTAINER # 镜像是谁写的，姓名 + 邮箱
RUN # 镜像构建的时候需要运行的命令
ADD # 步骤：tomcat镜像，这个tomcat压缩包！添加内容
WORKDIR # 镜像的工作目录
VOLUME # 挂载的目录
EXPOSE # 保留端口配置
CMD # 指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT # 指定这个容器启动的时候要运行的命令，可以追加命令
ONBUILD # 当构建一个被继承 DockerFile 这个时候就会运行 ONBUILD 的指令
COPY # 类似 ADD，将我们文件拷贝到镜像中
ENV # 构建的时候设置环境变量！实战测试：
# 创建一个自己的 centos
# RUN yum -y install vim
# RUN yum -y install net-tools
# 最基本的centos系统没有 vim ifconfig等基本命令，需要自己添加
1. 创建一个dockerfile文件 vim mydockerfile-centos
2. 写入启动的相关信息(编写配置文件)
FROM centos
MAINTAINER tangyuxiang<1227154999@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
3. 通过这个文件构建镜像
# 命令 docker build -f dockerfile文件路径 -t 镜像名:[tag] .
# docker build -f mydockerfile-centos -t mycentos:0.1 .
4. 测试运行
# docker run -it mycentos:0.1 (需要加版本号,不然会找寻最新版本的)
# docker history 镜像id # 可以看到镜像的运行命令CMD 和 ENTRYPOINT 区别：
CMD # 指定这个容器启动的时候要运行的命令，只有最后一个会生成，可被替代
ENTRYPOINT # 指定这个容器启动的时候要运行的命令，可以追加命令# 测试 CMD
1. 创建dockerfile文件
# vim dockerfile-cmd-test
FROM centos
CMD ["ls","-a"]
2. 构建镜像
# docker build -f dockerfile-cmd-test -t cmdtest .
3. 启动测试
# docker run 镜像名
# docker run cmdtest
# 结果：cmd命令进入容器立即执行！ 并且 启动的时候不能追加命令！# 测试 ENTRYPOINT
1. 创建 dockerfile 文件
# vim dockerfile-entrypoint-test
FROM centos
ENTRYPOINT ["ls","-a"]
2. 构建镜像
# docker build -f dockerfile-entrypoint-test -t entrypointtest .
3. 启动测试
# docker run entrypointtest
# docker run entrypointtest -l
# 结果：entrypoint命令进入容器立即执行！ 并且 启动的时候可以追加命令！实战：Tomcat镜像
1. 准备镜像文件 tomcat 压缩包, jdk 压缩包！
# 例如：home/build/tomcat/ 下边有 tomcat和jdk的安装包
2. 编写 dockerfile 文件, 官方命名 Dockerfile, build 会自动寻找这个文件, 就不需 要 -f 指定了！
FROM centos
MAINTAINER tangyuxiang<>
COPY readme.txt /usr/local/readme.txt
ADD jdk-8u281-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-9.0.44.tar.gz /usr/local/
RUN yum -y install vim
ENV MYPATH /usr/local
WORKDIR $MYPATH
ENV JAVA_HOME /usr/local/jdk-8u281-linux-x64
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.44
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.44
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
EXPOSE 8080
CMD /usr/local/apache-tomcat-9.0.44/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.44/bin/logs/catalina.out
3. 构建镜像 (因为取名为 ：Dockerfile , 所以不需要指定文件名)
# docker build -t diytomcat .
4. 启动镜像
docker run -d -p 9090:8080 --name tangyuxiangtomcat -v /home/tangyuxiang/build/tomcat/tomcatlogs/:/usr/local/apache-tomcat-9.0.44/logs -v /home/tangyuxiang/build/tomcat/test:/usr/local/apache-tomcat-9.0.44/webapps/test diytomcat
5. 访问测试
# 进入容器
# docker exec -it 容器id /bin/bash
# VM 访问测试
# curl localhost:9090
# 本机测试 http://ip:port/
# 测试结果：出现tomcat访问界面
6. 发布项目()
# 在test目录下放入 index.html页面 和 WEB-INF文件夹,文件夹下添加 web.xml 文件
# index.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>测试访问页面</title>
</head>
<body>
<h1>HHHHHHHHHHHHHHHHHHHHHH</h1>
</body>
</html>
# web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
version="2.4">
</web-app>
# 最后通过 http://ip:port/test/ 访问成功！发布自己的镜像：
DockerHub 上发布自己的镜像
# 地址：https://hub.docker.com/
服务器提交自己的镜像：
1. 登录(tangyuxiang:是自己的 dockerhub ID)
# docker login -u tangyuxiang
2. 提交镜像
# 改标签名：或者说另起一个镜像
# docker tag 镜像id 镜像名:[tag]
# docker tag 镜像id tangyuxiang/tangyuxiang:1.0
# docker tag 镜像ID Docker ID/仓库名:新的标签名(tag)
# docker push 镜像名:[tag]
# docker push tangyuxiang/tomcat:1.0
阿里云 发布镜像
# 未写# 镜像打包/镜像解压
# docker sava 命令
# docker load 命令Docker 网络：
网络连通：
# 通过 docker connect 命令 可以从一个容器打通另一个网段的网络：相当于这个容器在别的网段有一个ip：公网IP 内网IP
结论：假设要跨网络操作别人，就需要使用 docker network connect 连通！...实战：部署 Redis 集群：
SpringBoot 微服务打包 Docker 镜像：
1. 在本机打包一个 springboot项目 jar 包
2. 编写一个 Dockerfile 文件
FROM java:8
COPY *.jar /app.jar
CMD ["--server.port=8080"]
EXPOSE 8080
ENTRYPOINT ["java","-jar","/app.jar"]
3. 创建一个 docker 镜像 (build)
# docker build -t tyx666 .
4. 启动镜像
# docker run -d -p 8082:8080 --name tangyuxiang666 tyx666
5. 测试
# curl localhost:port
# http://ip:port/path/
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
