1.是什么

Dockerfile是用来构建Docker镜像的构建文件，是由一系列命令和参数构成的脚本。

2.构建三步骤

  1. 编写Dockerfile文件
  2. docker build 生成镜像
  3. docker run 镜像

3.Dockerfile构建过程解析

1）Dockerfile内容基础知识

  1. 每条保留字指令都必须为大写字母且后面要跟随至少一个参数
  2. 指令按照从上到下，顺序执行

  3. 表示注释

  4. 每条指令都会创建一个新的镜像层，并对镜像进行提交

2）docker执行dockerfile大致流程

  1. docker从基础镜像运行一个容器
  2. 执行一条指令并对容器作出修改
  3. 执行类似docker commit 的操作提交一个新的镜像层
  4. docker在基于刚提交的镜像运行一个容器
  5. 执行Dockerfile的下一条指令直到所有指令都执行完成

3）抽象

  • Dockerfile ——> .class
  • Docker镜像 ———> jar
  • Docker容器 ———-> 运行的jar

4.Dockerfile保留字指令

  1. FROM：基础镜像，当前新的镜像是基于哪个镜像的
  2. MAINTAINER：镜像维护者的名字和邮箱
  3. RUN：容器构建时需要运行的命令
  4. EXPOSE：当前容器对外暴露出的端口
  5. WORKDIR：指定在创建容器后，终端默认登录进来的工作目录，一个落脚点
  6. ENV:用来在构建镜像过程中设置环境变量
  7.     这个环境变量可以再后续任何RUN指令中使用，这就如同在命令前面指定了环境变量前缀一样
  8.     也可以在其他指令中直接使用
  9.     ENV MY_PATH/usr/local
  10.     WORKDIR $MY_PATH
  11. ADD:拷贝并解压
  12. COPY:拷贝
  13. VOLUME:容器数据卷，用于数据保存和持久化工作
  14. CMD:指定一个容器启动时要运行的命令
  15.     Dockerfile中可以有多个CMD命令，但是只有最后一个生效，CMD会被docker run之后的参数替换
  16. ENTRYPOINT:指定一个容器启动时要运行的命令
  17.     ENTRYPOINT的目的和CMD一样，都是在指定容器启动程序及参数
  18. ONBUILD:当构建一个被继承的Dockerfile时运行命令，父镜像再被子镜像继承后，父镜像的onbuild被触

5.自定义镜像mycentos

Base镜像：类似java的Object，99%的镜像都是通过在base镜像中安装和配置需要的软件构建出来的。

1.编写

  1. vim Dockerfile
  2. -------------------------------------------
  3. from centos
  4. #基础系统是centos
  5. maintainer yhd<1972039773@qq.com>
  6. #作者邮件
  7. env mypath /tmp
  8. #我的路径
  9. workdir /tmp
  10. #开始工作目录 $mypath
  11. run yum -y install vim
  12. #安装vim
  13. run yum -y install net-tools
  14. expose 80
  15. #暴露的端口
  16. cmd echo $mypath
  17. cmd echo "success---ok!"
  18. cmd /bin/bash
  19. --------------------------------------------

2.构建

  1. docker build -f /root/Dockerfile  -t mycentos:1.3

3.运行

  1. docker images 查看所有镜像，发现已经有了
  2. docker run -it mycentos:1.3

4.列出镜像的变更历史

  1. docker history mycentos:1.3

6.cmd-entrypoint命令案例

1）cmd ls

  1. docker build -f /root/Dockerfile -t mil:1.1 .
  2. docker run -it mil -al 会报错
  3. 因为命令行追加的参数会覆盖原有的cmd命令ls

2）entrypoint ls

  1. docker build -f /root/Dockerfile -t mi2:1.1
  2. docker run -it mi2 -al 会执行ls -al 
  3. 因为命令行追加的参数会与上一条命令合在一起 ls -al

7.onbuild命令

子镜像继承了父镜像，子镜像运行的时候，父镜像onbuild的命令就会执行

类似父类构造器写的代码，会在子类实例化以后执行

8.自定义tomcat9

  1. mkdir yhd
  2. cd yhd
  3. touch c.txt
  4. cp /opt/apache-tomcat-9.0.8.tar.gz /root/yhd/
  5. cp /opt/jdk-1.8.tar.gz /root/yhd/
  6. vim Dockerfile
  7. ----------------------
  8. from centos
  9. maintainer yhd<1972039773@qq.com>
  10. #吧c.txt拷贝到/usr/local/cincontainer.txt
  11. copy c.txt /usr/local/cincontainer.txt
  12. #吧java和tomcat添加到容器中
  13. add jdk -1.8.tar.gz /usr/local/
  14. add apache-tomcat-9.0.8.tar.gz /usr/local/
  15. #安装vim编辑器
  16. run yum -y install vim
  17. #设置家目录
  18. env mypath /usr/local
  19. workdir #mypath
  20. #配置java和tomcat环境变量
  21. env java_home /usr/local/jdk-1.8
  22. env classpath $java_home/lib/dt.jar:$java_home/lib/tools.jar
  23. env catalina_home /usr/local/apache-tomcat-9.0.8
  24. env catalina_base /usr/local/apache-tomcat-9.0.8
  25. env path $path:$java_home/bin:$catalina_home/lib:$catalina_home/bin
  26. #容器运行时监听的端口
  27. expose 8080
  28. #启动时运行tomcat
  29. #entrypoint ["/usr/local/apache-tomcat-9.0.8/binstartup.sh"]
  30. #cmd ["/usr/local/apache-tomcat-9.0.8/bin/catalina.sh","run"]
  31. cmd /usr/local/apache-tomcat-9.0.8/bin/startup.sh&& tail -F /usr/local/apache-tomcat-9.0.8/bin/logs/catalina.out
  32. ----------------------
  33. #构建
  34. docker build -t yhdTomcat9:1.1 .
  35. #如果dockerfile文件在当前目录下且就叫Dockerfile，可以省略 -f /root/yhd/Dockerfile
  36. #运行
  37. docker run -d -p 9080:8080 --name myt9 -v /root/yhd/tomcat9/test:/usr/local/apache-tomcat-9.0.8/webapps/test --privileged=true
  38. yhdTomcat9:1.1

9.总结

使用本地docker实例运行dockerfile

docker build ->image镜像

docker run ->docker 容器

容器->commit ->镜像->push <-pull