DockerFile介绍

dockerfile 是用来构建docker镜像的文件！命令参数脚本。

构建步骤

1、编写一个dockerfile文件。
2、docker build 构建为一个镜像。
3、docker run 运行镜像。
4、docker push 发布镜像（DockerHub、阿里云仓库）。

DockerFile构建过程

基础知识

1、每个保留关键字（指令）都必须是大写字母。
2、从上到下顺序执行指令。
3、#开头的代表注释。
4、每个指令都会创建提交为一个新的镜像层。
image.png
Dockerfile是面向开发的，我们以后要发布项目，做镜像，就需要编写dockerfile文件。
Docker镜像逐渐成为企业交付的标准，必须要掌握。
DockerFile：构建文件，定义了一切的步骤，源代码。
DockerImages：通过DockerFile构建生成的镜像，最终发布和运行产品。
Docker容器：容器就是镜像运行起来提供服务的。

DockerFile的指令

  1. FROM                # 基础镜像，一切从这里开始构建
  2. MAINTAINER    # 镜像是水榭的，姓名+邮箱
  3. RUN                    # 镜像构建的时候需要运行的命令, docker build时候运行
  4. ADD                    # add：步骤，tomcat镜像， 自动解压tomcat压缩包，添加内容，添加同目录
  5. WORKDIR            # 镜像的工作目录
  6. VOLUME            # 挂载的目录
  7. EXPOSE            # 容器保留的端口配置
  8. CMD                    # 指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代 docker run时候运行
  9. ENTRYPOINT    # 指定这个容器启动的时候要运行的命令，可以追加命令 docker run时候运行
  10. ONBUILD            # 当构建一个被继承DockerFile这个时候就会运行onbuild的指令，触发指令
  11. COPY                # 类似ADD，将我们的文件拷贝到镜像中
  12. ENV                    # 构建的时候设置环境变量

image.png

实战测试

创建一个自己的centos

  1. # 1、 /home下新建一个dockerfile目录
  2. $ mkdir dockerfile
  4. # 2、 dockerfile目录下新建mydockerfile-cnetos文件
  5. $ vim mydockerfile-centos
  7. # 3、 编写Dockerfile配置文件
  8. FROM centos                                                    # 基础镜像是官方原生的centos
  9. MAINTAINER author<email@email.com>  # 作者 
  11. ENV MYPATH /usr/local                                # 配置环境变量的目录
  12. WORKDIR $MYPATH                                            # 将工作目录设置为 MYPATH
  14. RUN yum -y install vim                            # 给官方原生的centos 增加vim命令
  15. RUN yum -y install net-tools                # 给官方原生的centos 增加 ifconfig命令
  17. EXPOSE 80                                                        # 暴露端口号为80
  19. CMD echo $MYPATH                    # 输出下 MYPATH 路径
  20. CMD echo "-----end----"                
  21. CMD /bin/bash                        # 启动后进入 /bin/bash
  24. # 4、通过这个文件构建镜像
  25. # 命令： docker build -f 文件路径 -t 镜像名:[tag] .
  26. $ docker build -f mydockerfile-centos -t mycentos:0.1 .
  28. # 5、出现下图后则构建成功

image.png

测试运行

  1. $ docker images
  2. REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
  3. mycentos            0.1                 cbf5110a646d        2 minutes ago       311MB
  4. # 6.测试运行
  5. $ docker run -it mycentos:0.1         # 注意带上版本号，否则每次都回去找最新版latest
  6. $ pwd    
  7. /usr/local                            # 与Dockerfile文件中 WORKDIR 设置的 MYPATH 一致
  8. $ vim                                # vim 指令可以使用
  9. $ ifconfig                             # ifconfig 指令可以使用
  10. # docker history 镜像id 查看镜像构建历史步骤
  11. $ docker history 镜像id

image.png
通过 docker history 镜像ID 可以列出本地进行的变更历史。
image.png

CMD 和 ENTRYPOINT区别

  1. CMD                   # 指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代。
  2.                                             # CMD指令指定的程序会被docker run命令行参数中指定要运行的程序所覆盖
  4. ENTRYPOINT            # 指定这个容器启动的时候要运行的命令，可以追加命令。
  5.                                             # 不会被docker run的命令行参数指定的指令所覆盖，这些命令行参数会被当做参数送给ENTRYPOINT指令指定的程序

测试CMD

  1. # 编写dockerfile文件
  2. $ vim dockerfile-test-cmd
  3. FROM centos
  4. CMD ["ls","-a"]                    # 启动后执行 ls -a 命令
  6. # 构建镜像
  7. $ docker build  -f dockerfile-test-cmd -t cmd-test:0.1 .
  9. # 运行镜像
  10. $ docker run cmd-test:0.1        # 由结果可得，运行后就执行了 ls -a 命令
  11. .
  12. ..
  13. .dockerenv
  14. bin
  15. dev
  16. etc
  17. home
  19. # 想追加一个命令  -l 成为ls -al：展示列表详细数据
  20. $ docker run cmd-test:0.1 -l
  21. docker: Error response from daemon: OCI runtime create failed: container_linux.go:349: starting container process caused "exec: \"-l\":
  22. executable file not found in $PATH": unknown.
  23. ERRO[0000] error waiting for container: context canceled 
  24. # cmd的情况下 -l 替换了CMD["ls","-l"] 而 -l  不是命令所以报错

测试ENTRYPOINT

  1. # 编写dockerfile文件
  2. $ vim dockerfile-test-entrypoint
  3. FROM centos
  4. ENTRYPOINT ["ls","-a"]
  6. # 构建镜像
  7. $ docker build  -f dockerfile-test-entrypoint -t cmd-test:0.1 .
  9. # 运行镜像
  10. $ docker run entrypoint-test:0.1
  11. .
  12. ..
  13. .dockerenv
  14. bin
  15. dev
  16. etc
  17. home
  18. lib
  19. lib64
  20. lost+found ...
  22. # 我们的命令，是直接拼接在我们得ENTRYPOINT命令后面的
  23. $ docker run entrypoint-test:0.1 -l
  24. total 56
  25. drwxr-xr-x   1 root root 4096 May 16 06:32 .
  26. drwxr-xr-x   1 root root 4096 May 16 06:32 ..
  27. -rwxr-xr-x   1 root root    0 May 16 06:32 .dockerenv
  28. lrwxrwxrwx   1 root root    7 May 11  2019 bin -> usr/bin
  29. drwxr-xr-x   5 root root  340 May 16 06:32 dev
  30. drwxr-xr-x   1 root root 4096 May 16 06:32 etc
  31. drwxr-xr-x   2 root root 4096 May 11  2019 home
  32. lrwxrwxrwx   1 root root    7 May 11  2019 lib -> usr/lib
  33. lrwxrwxrwx   1 root root    9 May 11  2019 lib64 -> usr/lib64 ....

实战：Tomcat镜像

1、准备镜像文件

  1. 准备tomcat 和 jdk 到当前目录，编写好README

image.png

2、 编写dockerfile

  1. $ vim dockerfile
  2. FROM centos                                                                                        # 基础镜像centos
  3. MAINTAINER auther<email>                                                            # 作者
  4. COPY README /usr/local/README                                                    # 复制README文件
  5. ADD jdk-8u231-linux-x64.tar.gz /usr/local/
  6. ADD apache-tomcat-9.0.35.tar.gz /usr/local/             # 添加tomcat，ADD 命令会自动解压
  7. RUN yum -y install vim                                # 安装 vim 命令
  8. ENV MYPATH /usr/local                                 # 环境变量设置 工作目录
  9. WORKDIR $MYPATH
  10. ENV JAVA_HOME /usr/local/jdk1.8.0_231                 # 环境变量： JAVA_HOME环境变量
  11. ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
  12. ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.35     # 环境变量： tomcat环境变量
  13. ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.35
  14. # 设置环境变量 分隔符是：
  15. ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin     
  16. EXPOSE 8080                                             # 设置暴露的端口
  17. CMD /usr/local/apache-tomcat-9.0.35/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.35/logs/catalina.out                     # 设置默认命令

3、构建镜像

  1. # 因为dockerfile命名使用默认命名 因此不用使用 -f 指定文件
  2. $ docker build -t mytomcat:0.1 .

4、run镜像

  1. # -d 后台运行， -p:暴露端口 --name:别名 -v：绑定路径
  2. $ docker run -d -p 8080:8080 --name tomcat01 
  3. -v /home/kuangshen/build/tomcat/test:/usr/local/apache-tomcat-9.0.35/webapps/test 
  4. -v /home/kuangshen/build/tomcat/tomcatlogs/:/usr/local/apache-tomcat-9.0.35/logs
  5. mytomcat:0.1

5、访问测试

  1. $ docker exec -it 自定义容器的id /bin/bash
  2. $ cul localhost:8080

6、发布项目

由于做了卷挂载，我们直接在本地编写项目就可以发布了。
发现：项目部署成功，可以直接访问。
开发步骤：需要掌握Dockerfile的编写！之后他的一切都是使用docker镜像来发布运行的。

发布自己的镜像

发布到Docker Hub

1、地址 https://hub.docker.com/
2、确定这个账号可以登录
3、 登录
4、 提交push镜像

  1. $ docker login --help
  2. Usage:  docker login [OPTIONS] [SERVER]
  3. Log in to a Docker registry.
  4. If no server is specified, the default is defined by the daemon.
  5. Options:
  6.   -p, --password string   Password
  7.       --password-stdin    Take the password from stdin
  8.   -u, --username string   Username
  9. $ docker login -u 你的用户名 -p 你的密码
  11. $ docker push mytomcat
  1. # 会发现push不上去，因为如果没有前缀的话默认是push到 官方的library
  2. # 解决方法：
  3. # 第一种 build的时候添加你的dockerhub用户名，然后在push就可以放到自己的仓库了
  4. $ docker build -t kuangshen/mytomcat:0.1 .
  6. # 第二种 使用docker tag #然后再次push
  7. $ docker tag 容器id kuangshen/mytomcat:1.0 #然后再次push
  8. $ docker push kuangshen/mytomcat:1.0

发布到 阿里云镜像服务上

看官网很详细https://cr.console.aliyun.com/repository/

  1. $ sudo docker login --username=zchengx registry.cn-shenzhen.aliyuncs.com
  2. $ sudo docker tag [ImageId] registry.cn-shenzhen.aliyuncs.com/dsadxzc/cheng:[镜像版本号]
  3. # 修改id 和 版本
  4. sudo docker tag a5ef1f32aaae registry.cn-shenzhen.aliyuncs.com/dsadxzc/cheng:1.0
  5. # 修改版本
  6. $ sudo docker push registry.cn-shenzhen.aliyuncs.com/dsadxzc/cheng:[镜像版本号]

小结

image.png