1.docker介绍、命令、容器、镜像、数据卷、Dockerfile、常用软件安装、推送阿里云

一、docker介绍

1、docker是什么

• 一款产品从开发到上线，从操作系统，到运行环境，再到应用配置。作为开发+运维之间的协作我们需要关心很多东西，这也是很多互联网公司都不得不面对的问题，特别是各种版本的迭代之后，不同版本环境的兼容，对运维人员都是考验，环境配置如此麻烦，换一台机器，就要重来一次，费力费时。很多人想到，能不能从根本上解决问题，软件可以带环境安装？也就是说，安装的时候，把原始环境一模一样地复制过来。开发人员利用Docker可以消除协作编码时“在我的机器上可正常工作”的问题。原始的部署方式是开发人员只将程序打包好发送给运维人员，造成了开发环境和生产环境有差异，docker可以将运行环境进行打包，到达将开发环境和生产环境一致
• Docker是基于Go语言实现的云开源项目
• Docker的主要目标是“Build，Ship and Run Any App,Anywhere”，也就是通过对应用组件的封装、分发、部署、运行等生命周期的管理，使用户的APP（可以是一个WEB应用或数据库应用等等）及其运行环境能够做到“一次封装，到处运行”
• Linux容器技术的出现就解决了这样一个问题，而Docker就是在它的基础上发展过来的。将应用运行在Docker容器上面，而Docker容器在任何操作系统上都是一致的，这就实现了跨平台、跨服务器。只需要一次配置好环境，换到别的机子上就可以一键部署好，大大简化了操作
• 解决了运行环境和配置问题软件容器，方便做持续集成并有助于整体发布的容器虚拟化技术

2、docker优点

• 虚拟机就是带环境安装的一种解决方案，在一个操作系统上模拟出另外一个操纵系统，在模拟的操作系统上再运行程序，应用程序毫无感知，对底层操作系统来说，虚拟机就是一个文件不需要可以删掉，完美的模拟硬件，操作系统和应用之间的关系
• 
• Docker和虚拟机对比
  • 虚拟机和docker都需要运行在底层操作系统之上，虚拟机利用虚拟机管理软件（例如：VMware），而docker依赖其守护进程
  • 虚拟机管理软件会虚拟出一个完整的机器（包含操作系统，硬件存储等），在该系统上再运行所需应用进程；而docker内的应用进程直接运行于宿主的内核，容器内没有自己的内核，而且也没有进行硬件虚拟，因此容器要比传统虚拟机更为轻便只会虚拟出一个容器应用，底层使用的还是宿主机的硬件，每个容器之间互相隔离，每个容器有自己的文件系统 ，容器之间进程不会相互影响，能区分计算资源
  • 虚拟机资源占用多、冗余步骤多、启动慢，而docker资源占用少，操作简单，启动快
  • docker一次构建、随处运行
    • 更快速的应用交付和部署
    • 更便捷的升级和扩缩容
    • 更简单的系统运维
    • 更高效的计算资源利用
• 相关网站
  • 官网：https://www.docker.com
  • docker-hub：https://hub.docker.com/

3、docker安装

3.1、前提条件

• centos安装docker需要6.5版本以上
• centos仅发行版中的内容支持，centos7要求64位，内核版本3.10以上，centos6.5要求64位，内核版本3.6.32-431以上
• uname -r 查看内核版本
• cat /etc/redhat-release 查看系统

3.2、docker架构

• 

• 说明

  • docker的客户端都是和docker的守护进程进行交互
  • Docker镜像（Image）就是一个只读的模板。镜像可以用来创建Docker容器，一个镜像可以创建很多容器
  • Docker利用容器（Container）独立运行的一个或一组应用。容器是用镜像创建的运行实例。它可以被启动、开始、停止、删除。每个容器都是相互隔离的、保证安全的平台。可以把容器看做是一个简易版的Linux环境（包括root用户权限、进程空间、用户空间和网络空间等）和运行在其中的应用程序。容器的定义和镜像几乎一模一样，也是一堆层的统一视角，唯一区别在于容器的最上面那一层是可读可写的。
  • 仓库（Repository）是集中存放镜像文件的场所。仓库(Repository)和仓库注册服务器（Registry）是有区别的。仓库注册服务器上往往存放着多个仓库，每个仓库中又包含了多个镜像，每个镜像有不同的标签（tag），仓库分为公开仓库（Public）和私有仓库（Private）两种形式。最大的公开仓库是 Docker Hub(https://hub.docker.com/)，存放了数量庞大的镜像供用户下载。国内的公开仓库包括阿里云 、网易云等
  • 通俗理解：镜像就是类，容器就是对象，一个类可以创建多个对象，互不影响，仓库和maven一样，存放镜像的地方

3.3、docker安装

• docker的安装参考官网，有两种方式，自动安装手动安装

卸载

• sudo yum remove docker
  
  docker-client
  
  docker-client-latest
  
  docker-common
  
  docker-latest
  
  docker-latest-logrotate
  
  docker-logrotate
  
  docker-engine

自动安装

• yum install docker
• 验证安装是否成功：docker version

手动安装

• 1.安装gcc相关：yum -y install gcc，yum -y install gcc-c++

• 2.安装所需的软件包yum-utils提供了yum-config-manager ，并且device mapper 存储驱动程序需要device-mapper-persistent-data和lvm2

  • sudo yum install -y yum-utils device-mapper-persistent-data lvm2

• 3.设置仓库（注意选择国内，国外很慢）sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

• 4.安装最新版本的Docker Engine-Community和containerd，或者安装特定版本

  • sudo yum install docker-ce docker-ce-cli containerd.io
    • centos8安装报错Problem: package docker-ce-3:19.03.14-3.el7.x86_64 requires containerd.io >= 1.2.2-3, but none of the providers can be installed解决方式
      • 更新yum：yum update
      • 安装依赖环境：yum install -y yum-utils device-mapper-persistent-data lvm2
      • 添加docker源：sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
      • 安装新版containerd.io：dnf install https://download.docker.com/linux/centos/7/x86_64/stable/Packages/containerd.io-1.2.6-3.3.el7.x86_64.rpm
      • 再次安装：sudo yum install docker-ce docker-ce-cli containerd.io
  • 5.启动docker：sudo systemctl start docker
  • 6.运行Hello world：sudo docker run hello-world 本地找不见不自动去库中下载

  • 7.配置阿里云镜像加速器

    • 获取加速器链接地址：https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors
    • 创建目录：mkdir -p /etc/docker
    • 创建配置文件：vim /etc/docker/daemon.json 并写入{"registry-mirrors": ["https://｛自已的编码｝.mirror.aliyuncs.com"]}
    • 重启docker：sudo systemctl daemon-reload，sudo systemctl restart docker
    • 检测：docker info
      
      Registry Mirrors:
      
      https://reg-mirror.qiniu.com

开机自启

• systemctl start docker.service
• systemctl enable docker.service
• systemctl grep docker查看docker进程的状态

4、docker原理

• Docker是一个Client-Server结构的系统，Docker守护进程运行在主机上， 然后通过Socket连接从客户端访问，守护进程从客户端接受命令并管理运行在主机上的容器。 容器，是一个运行时环境,就是我们前面说到的集装箱。
• docker有着比虚拟机更少的抽象层。由亍docker不需要Hypervisor实现硬件资源虚拟化,运行在docker容器上的程序直接使用的都是实际物理机的硬件资源。因此在CPU、内存利用率上docker将会在效率上有明显优势。
• docker利用的是宿主机的内核,而不需要Guest OS。因此,当新建一个容器时,docker不需要和虚拟机一样重新加载一个操作系统内核。仍而避免引寻、加载操作系统内核返个比较费时费资源的过程,当新建一个虚拟机时,虚拟机软件需要加载Guest OS,返个新建过程是分钟级别的。而docker由于直接利用宿主机的操作系统,则省略了返个过程,因此新建一个docker容器只需要几秒钟。
• 

二、docker常用命令

1、帮助命令

• 查看版本：docker version
• 查看详细信息：docker info
• 帮助 docker --help

2、镜像命令

2.1、列出本地主机上的镜像

• docker images
  • REPOSITORY：表示镜像的仓库源
  • TAG：镜像的标签 同一仓库源可以有多个TAG，代表这个仓库源的不同个版本，我们使用REPOSITORY:TAG来定义不同的镜像。如果你不指定一个镜像的版本，你只写ubuntu，docker 将默认使用ubuntu:latest 镜像
  • IMAGE ID：镜像ID
  • CREATED：镜像创建时间
  • SIZE：镜像大小
• 参数
  • -a：列出本地所有镜像（包含中间映像层）
  • -q：只显示镜像id
  • --digests：只显示摘要信息
  • --no-trunc：显示完整的镜像信息（列出完整的id）
• 常用
  • docker images -qa

2.2、在库中搜索镜像

• docker search 镜像名
• 参数
  • --no-trunc：显示完整的镜像信息
  • -s：列出收藏数不小于指定值的镜像
  • --automated：只列出automated build类型的镜像（自己构建的）

2.3、拉取指定镜像

• docker pull 镜像名:TAG，不写TAG默认latest

2.4、删除指定镜像

• docker rmi -f 镜像名或id
• 常用
  • 批量删除：docker rmi -f 镜像名1:TAG 镜像名2:TAG
  • 删除全部：docker rmi -f $(docker images -qa)

3、容器命令

3.1、新建并启动容器

• docker run [options] 镜像 [command] [arg...]
• 参数
  • --name="容器新名字": 为容器指定一个名称，不写随机分配
  • -d: 后台运行容器，并返回容器ID，也即启动守护式容器
  • -i：以交互模式运行容器，通常与-t同时使用
  • -t：为容器重新分配一个伪输入终端，通常与-i同时使用
  • -P: 随机端口映射
  • -p: 指定端口映射，有以下四种格式
    • ip:hostPort:containerPort
    • ip::containerPort
    • hostPort:containerPort
    • containerPort
• 注意：如果启动一个守护式容器，没有前台(终端也算)进行，啥也不做，刚启动就会被自动关闭

3.2、列出当前正在运行的容器

• docker ps [option]
• 参数
  • -a：列出当前所有正在运行的容器+历史上运行过的
  • -l：显示最近创建的容器
  • -n：显示最近n个创建的容器 例如-n 10
  • -q：静默模式，只显示容器编号
  • --no-trunc :不截断输出（完整id）

3.3、退出容器

• exit：退出并停止容器
• ctrl+P+Q：退出不停止退出（推荐）

3.4、启动容器

• docker start 容器id或容器名

3.5、重启容器

• docker restart 容器id或容器名

3.6、停止容器

• 停止：docker stop 容器id或容器名
• 强制停止：docker kill 容器id或容器名

3.7、删除已经停止的

• 删除一个：docker rm 容器id
• 删除所有：docker rm -f $(docker ps -a -q)或者docker ps -a -q | xargs docker rm(linux管道的形式，上一个命令的返回值作为下一个命令的输入)

3.8、启动守护式容器

• docker run -d 容器名（例如：docker run -d centos）返回一个容器id
• 然后docker ps -a 进行查看, 会发现容器已经退出
  • 很重要的要说明的一点: Docker容器后台运行,就必须有一个前台进程，容器运行的命令如果不是那些一直挂起的命令（比如运行top，tail），就是会自动退出的
  • 这个是docker的机制问题,比如你的web容器,我们以nginx为例，正常情况下,我们配置启动服务只需要启动响应的service即可。例如service nginx start但是,这样做,nginx为后台进程模式运行,就导致docker前台没有运行的应用,这样的容器后台启动后,会立即自杀因为他觉得他没事可做了.所以，最佳的解决方案是,将你要运行的程序以前台进程的形式运行

3.9、查看容器日志

• docker logs [option] 容器id （也就是容器内部终端显示的内容） 按ctrl+c可以退出
• 参数
  • -t：是加入时间戳
  • -f：跟随最新的日志打印
  • --tail 数字：显示最后多少条
• 例如在容器内运行shell脚本：docker run -d centos /bin/sh -c "while true;do echo hello zzyy;sleep 2;done"

3.10、查看容器内部运行的进程

• docker top 容器id

3.11、查看容器内部细节

• docker inspect 容器id

3.12、与容器交互

• docker attach 容器id
  • 直接进入容器启动命令终端，不会创建新的进程（容器里面原来存在的终端），若使用的exit退出到宿主机，会停止容器
• docker exec -it 容器id shell命令(必须)
  • 是在容器中打开新的终端，并且可以启动新的进程，使用exit退出到宿主机，容器也不会停止
  • 例如：docker exec -it 容器id /bin/bash——>进入容器打开一个新的终端
  • 例如：docker exec -it 容器id ls——>返回进入容器默认目录的文件列表（隔空取物：不需要进入容器）
  • 例如：docker exec -it 容器id ls /tmp——>返回容器tmp目录的文件列表（隔空取物：不需要进入容器）

3.13、拷贝文件

• docker cp 容器id:容器内路径 目的主机路径

三、镜像原理

1、镜像结构

• 镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件，它包含运行某个软件所需的所有内容，包括代码、运行时、库、环境变量和配置文件
• UnionFS（联合文件系统）
  • Union文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。Union文件系统是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等等
  • 
  • 平时我们安装进虚拟机的CentOS都是好几个G，为什么docker这里才200M？
    • 对于一个精简的OS，rootfs可以很小，只需要包括最基本的命令、工具和程序库就可以了，因为底层直接用Host的kernel，自己只需要提供 rootfs 就行了。由此可见对于不同的linux发行版, bootfs基本是一致的, rootfs会有差别, 因此不同的发行版可以公用bootfs
  • 为什么docker中的tomcat很大，几百兆？
    • 
    • 因为tomcat镜像中还包含了所依赖的其他库文件，kernel内核、centos、jdk8、tomcat，所以可以说一个镜像像一个微型的linux系统，包含了一个应用的运行环境，多层文件进行叠加，最终暴露出一个镜像文件
    • 下载时分层下载
      • 
• 分层的优点
  • 最大的一个好处就是 - 共享资源
  • 比如：有多个镜像都从相同的 base 镜像构建而来，那么宿主机只需在磁盘上保存一份base镜像，同时内存中也只需加载一份 base 镜像，就可以为所有容器服务了。而且镜像的每一层都可以被共享
• 结构特点
  • docker镜像都是只读的
  • 当容器启动时，一个新的可写层被加载到镜像的顶部，这一层通常被称作容器层，容器层之下的都叫镜像层

2、docker commit

• 将一个容器提交成一个新的容器
• docker commit -m="提交的描述信息" -a="作者" 容器id 要创建的目标镜像名:[TAG] 不写默认latest
• 案例
  • 拉取tomcat8.5.31镜像，运行后删除webapps目录下的doc目录（rm -rf 目录名）（其他版本的tomcat的webapps目录下为空，启动之后直接访问报404是正常的）
  • 将该容器commit提交成一个新的镜像
  • 使用新镜像运行一个容器，点击document是否是404

四、容器数据卷

1、概述

• 遇到的问题
  • 将运用与运行的环境打包形成容器运行 ，运行可以伴随着容器，数据不能持久化，容器之间不能共享数据
  • 持久化传统方式：通过docker commit生成新的镜像，使得数据做为镜像的一部分保存下来
• 解决方式
  • 容器数据卷：有点类似rdb和aof，持久化容器中的数据和容器间继承+共享数据

2、数据卷

• 解决容器中数据的持久化

• 解决方式：将容器中重要的数据保存到宿主机上

• 方式一：启动容器时指定映射关系

  • 命令：docker run -it -v /宿主机目录:/容器内目录 镜像 /bin/bash （-v：指定映射关系，可以有多个，如果目录不存在，会创建目录）

  • 查看是否成功：docker inspect 容器id （RW：代表容器对该目录可读可写，Source为主机目录，Destination为容器目录）

    • "Mounts": [
      
      {
      
      "Type": "bind",
      
      "Source": "/tmp/hosttest",
      
      "Destination": "/tmp/containertest",
      
      "Mode": "",
      
      "RW": true,
      
      "Propagation": "rprivate"
      
      }
      
      ],

  • 测试

    • 测试1：两边都修改，看是否生效

      • 1.主机写入文件
        [root@localhost hosttest]# echo "I'm host" > a.txt
        [root@localhost hosttest]# cat a.txt
        I'm host
        2.容器修改文件
        [root@51037b519837 containertest]# vi a.txt
        [root@51037b519837 containertest]# cat a.txt
        I'm host
        container update
        3.主机查看文件
        [root@localhost hosttest]# cat a.txt
        I'm host
        container update
        
        

    • 测试2：关闭容器，主机修改文件，看是否生效

      • 1.关闭容器
        [root@localhost hosttest]# docker kill 51037b519837
        51037b519837
        2.主机上修改文件
        [root@localhost hosttest]# vim a.txt
        [root@localhost hosttest]# cat a.txt
        I'm host
        container update
        host update
        3.启动容器
        [root@localhost hosttest]# docker start 51037b519837
        51037b519837
        4.查看文件
        [root@localhost hosttest]# docker exec -it 51037b519837 /bin/bash
        [root@51037b519837 /]# cd /tmp/containertest/
        [root@51037b519837 containertest]# cat a.txt
        I'm host
        container update
        host update
        

    • 结论：不管容器是否关闭，主机修改文件，容器启动后都会更新，相当于java中两个引用指向的是同一个内存地址

  • 带权限的命令：docker run -it -v /宿主机目录:/容器内目录:ro 镜像 /bin/bash （-v：指定映射关系，可以有多个，如果目录不存在，会创建目录；ro：代表read only只读，容器中不可修改）

    • 1.创建容器
      [root@localhost hosttest]# docker run -it -v /tmp/hosttestro:/tmp/containertestro:ro --name ctro centos
      [root@9d0eef947060 /]#
      2.查看是否成功 rw已经变成了false
      [root@localhost hosttest]# docker inspect 9d0eef947060
      "Mounts": [
                  {
                      "Type": "bind",
                      "Source": "/tmp/hosttestro",
                      "Destination": "/tmp/containertestro",
                      "Mode": "ro",
                      "RW": false,
                      "Propagation": "rprivate"
                  }
              ],
      3.在host上新建文件并写入
      [root@localhost hosttestro]# echo "I'm read only" > rotest.txt
      [root@localhost hosttestro]# cat rotest.txt
      I'm read only
      4.进入容器修改
      [root@localhost hosttestro]# docker exec -it 9d0eef947060 /bin/bash
      [root@9d0eef947060 /]# cd tmp/containertestro/
      [root@9d0eef947060 containertestro]# ls
      rotest.txt
      [root@9d0eef947060 containertestro]# vi rotest.txt
      5.发现vi不能编辑该文件
      -- INSERT -- W10: Warning: Changing a readonly file
      6.也不能自己新建文件
      [root@9d0eef947060 containertestro]# echo "I'm container" > aa.txt
      bash: aa.txt: Read-only file system
      
      

• 方式二：使用DockerFile在构建镜像时指定

  • DockerFile指令：VOLUME["容器目录1","容器目录2","容器目录3",...]

    • 出于可移植和分享的考虑，用-v 主机目录:容器目录这种方法不能够直接在Dockerfile中实现。由于宿主机目录是依赖于特定宿主机的，并不能够保证在所有的宿主机上都存在这样的特定目录

  • 创建DockerFile文件，并写入内容

    • [root@localhost mydocker]# vim dockerfile
      [root@localhost mydocker]# cat dockerfile
      # volume test
      
      FROM centos
      
      VOLUME ["/dataVolumeContainer1","/dataVolumeContainer2"]
      
      CMD echo "finished,--------success1"
      
      CMD /bin/bash
      [root@localhost mydocker]#
      
      

  • 命令构建镜像

    • docker build -f /test/mydocker/dockerfile -t ma/centos:1.0 . (-f：指定dockfile文件路径；.：最后的点不能省略，指定的是构建的上下文环境)

    • [root@localhost mydocker]# docker images
      REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
      ma/centos           1.0                 6c074087077c        37 seconds ago      209MB
      mytomcat            1.0                 ca4cffd1de8f        15 hours ago        463MB
      centos              latest              300e315adb2f        26 hours ago        209MB
      tomcat              8.5.31              df50c9d355cf        2 years ago         463MB
      
      

  • 启动镜像并查看数据卷在主机的位置

    • [root@localhost mydocker]# docker run -it ma/centos:1.0
      [root@c86811d3480e /]# [root@localhost mydocker]#
      [root@localhost mydocker]# docker inspect c86811d3480e
       "Mounts": [
                  {
                      "Type": "volume",
                      "Name": "bf9c3b442d1f754f6a80c3496a8f251b31e6ae962871c123f8142a253cc1904c",
                      "Source": "/var/lib/docker/volumes/bf9c3b442d1f754f6a80c3496a8f251b31e6ae962871c123f8142a253cc1904c/_data",
                      "Destination": "/dataVolumeContainer1",
                      "Driver": "local",
                      "Mode": "",
                      "RW": true,
                      "Propagation": ""
                  },
                  {
                      "Type": "volume",
                      "Name": "2e26e661586d11af53ab8d322016458e392c2e1aa4d9727d84b11a3da1e03f99",
                      "Source": "/var/lib/docker/volumes/2e26e661586d11af53ab8d322016458e392c2e1aa4d9727d84b11a3da1e03f99/_data",
                      "Destination": "/dataVolumeContainer2",
                      "Driver": "local",
                      "Mode": "",
                      "RW": true,
                      "Propagation": ""
                  }
              ],
      
      

  • Docker挂载主机目录Docker访问出现cannot open directory .: Permission denied 解决办法：在挂载目录后多加一个--privileged=true参数即可

3、数据卷容器

• 命名的容器挂载数据卷，其它容器通过挂载这个(父容器)实现数据共享，挂载数据卷的容器，称之为数据卷容器

• 实现方式

  • 启动一个父容器

    • docker run -it --name dc1 ma/centos:1.0

  • 挂载两个子容器 使用--volumes-from参数

    • docker run -it --name dc2 --volumes-from dc1 ma/centos:1.0
    • docker run -it --name dc3 --volumes-from dc1 ma/centos:1.0

  • 测试

    • 在dc1中添加文件，dc2，dc3也添加
    • 删除dc1，修改dc2中文件，dc3也修改了
    • 删除dc2，dc3仍旧可以访问
    • 新建dc4继承dc3，删除dc3，dc4仍旧可以访问

  • 容器之间配置信息的传递，数据卷的生命周期一直持续到没有容器使用它为止

  • 本质原因：配置信息的传递

    • 1.创建dc1，dc2、dc3、dc4容器卷继承dc1，dc4使用原始镜像，不包含VOLUME指令
      docker run -it --name dc1 ma/centos:1.0
      docker run -it --name dc2 --volumes-from dc1 ma/centos:1.0
      docker run -it --name dc3 --volumes-from dc1 ma/centos:1.0
      docker run -it --name dc4 --volumes-from dc1 centos (dc4使用原始镜像，不包含VOLUME指令)
      2.根据容器id查看各自的信息
      [root@localhost _data]# docker inspect dc1
      "Mounts": [
                  {
                      "Type": "volume",
                      "Name": "ce66ad2a242a771b9735717ec305521dfcbad324adbee58bd6dea2795fc1b4f0",
                      "Source": "/var/lib/docker/volumes/ce66ad2a242a771b9735717ec305521dfcbad324adbee58bd6dea2795fc1b4f0/_data",
                      "Destination": "/dataVolumeContainer1",
                      "Driver": "local",
                      "Mode": "",
                      "RW": true,
                      "Propagation": ""
                  },
                  {
                      "Type": "volume",
                      "Name": "160ec2ca48392b73c53c2dbe709d414c81ca6be1dfeb85d70e4f7dc37c3fc892",
                      "Source": "/var/lib/docker/volumes/160ec2ca48392b73c53c2dbe709d414c81ca6be1dfeb85d70e4f7dc37c3fc892/_data",
                      "Destination": "/dataVolumeContainer2",
                      "Driver": "local",
                      "Mode": "",
                      "RW": true,
                      "Propagation": ""
                  }
              ],
      [root@localhost _data]# docker inspect dc2
      "Mounts": [
                  {
                      "Type": "volume",
                      "Name": "160ec2ca48392b73c53c2dbe709d414c81ca6be1dfeb85d70e4f7dc37c3fc892",
                      "Source": "/var/lib/docker/volumes/160ec2ca48392b73c53c2dbe709d414c81ca6be1dfeb85d70e4f7dc37c3fc892/_data",
                      "Destination": "/dataVolumeContainer2",
                      "Driver": "local",
                      "Mode": "",
                      "RW": true,
                      "Propagation": ""
                  },
                  {
                      "Type": "volume",
                      "Name": "ce66ad2a242a771b9735717ec305521dfcbad324adbee58bd6dea2795fc1b4f0",
                      "Source": "/var/lib/docker/volumes/ce66ad2a242a771b9735717ec305521dfcbad324adbee58bd6dea2795fc1b4f0/_data",
                      "Destination": "/dataVolumeContainer1",
                      "Driver": "local",
                      "Mode": "",
                      "RW": true,
                      "Propagation": ""
                  }
              ],
      
      [root@localhost _data]# docker inspect dc3
      "Mounts": [
                  {
                      "Type": "volume",
                      "Name": "ce66ad2a242a771b9735717ec305521dfcbad324adbee58bd6dea2795fc1b4f0",
                      "Source": "/var/lib/docker/volumes/ce66ad2a242a771b9735717ec305521dfcbad324adbee58bd6dea2795fc1b4f0/_data",
                      "Destination": "/dataVolumeContainer1",
                      "Driver": "local",
                      "Mode": "",
                      "RW": true,
                      "Propagation": ""
                  },
                  {
                      "Type": "volume",
                      "Name": "160ec2ca48392b73c53c2dbe709d414c81ca6be1dfeb85d70e4f7dc37c3fc892",
                      "Source": "/var/lib/docker/volumes/160ec2ca48392b73c53c2dbe709d414c81ca6be1dfeb85d70e4f7dc37c3fc892/_data",
                      "Destination": "/dataVolumeContainer2",
                      "Driver": "local",
                      "Mode": "",
                      "RW": true,
                      "Propagation": ""
                  }
              ],
      [root@localhost _data]# docker inspect dc4
      "Mounts": [
                  {
                      "Type": "volume",
                      "Name": "ce66ad2a242a771b9735717ec305521dfcbad324adbee58bd6dea2795fc1b4f0",
                      "Source": "/var/lib/docker/volumes/ce66ad2a242a771b9735717ec305521dfcbad324adbee58bd6dea2795fc1b4f0/_data",
                      "Destination": "/dataVolumeContainer1",
                      "Driver": "local",
                      "Mode": "",
                      "RW": true,
                      "Propagation": ""
                  },
                  {
                      "Type": "volume",
                      "Name": "160ec2ca48392b73c53c2dbe709d414c81ca6be1dfeb85d70e4f7dc37c3fc892",
                      "Source": "/var/lib/docker/volumes/160ec2ca48392b73c53c2dbe709d414c81ca6be1dfeb85d70e4f7dc37c3fc892/_data",
                      "Destination": "/dataVolumeContainer2",
                      "Driver": "local",
                      "Mode": "",
                      "RW": true,
                      "Propagation": ""
                  }
              ],
      
      

    • 发现dc1，dc2，dc3，dc4宿主机的容器卷是同一个位置，所以才会达到各个容器共享，即使dc4的镜像本身没有指定容器卷，也会通过继承的形式将容器卷从dc1上继承过来

五、Dockerfile

1、概述

• Dockfile用来构建镜像文件，由一系列命令和参数构成的脚本
• 构建三步骤
  • 编写dockerfile
  • docker build
  • docker run
• 基本规则
  • 每个保留字指令都要大写并且后面至少跟一个参数
  • 指令从上到下顺序执行
  • '#'表示注释
  • 每条指令都会创建一个新的镜像层，并对镜像提交
• 执行流程
  • docker从基础镜像运行一个容器
  • 执行一条指令对容器进行修改
  • 执行类似docker commit 的操作提交一个新的镜像层
  • docker再基于刚才提交新的镜像启动一个新容器
  • 执行dockerfile的下一条指令直到所有指令执行完成
• 从应用软件的角度来看，Dockerfile、Docker镜像与Docker容器分别代表软件的三个不同阶段，
  • Dockerfile是软件的原材料
    • 需要定义一个Dockerfile，Dockerfile定义了进程需要的一切东西。Dockerfile涉及的内容包括执行代码或者是文件、环境变量、依赖包、运行时环境、动态链接库、操作系统的发行版、服务进程和内核进程(当应用进程需要和系统服务和内核进程打交道，这时需要考虑如何设计namespace的权限控制)等等;
  • Docker镜像是软件的交付品
    • 在用Dockerfile定义一个文件之后，docker build时会产生一个Docker镜像，当运行 Docker镜像时，会真正开始提供服务
  • Docker容器则可以认为是软件的运行态
    • 容器是直接提供服务的
  • Dockerfile面向开发，Docker镜像成为交付标准，Docker容器则涉及部署与运维，三者缺一不可，合力充当Docker体系的基石

2、dockerfile指令

• FROM：指定基础镜像，DockerHub中99%的镜像通过scratch镜像构建出来的
• MAINTAINER：指定作者和邮箱 例如：作者名<邮箱>
• RUN：容器构建时运行的命令
• EXPOSE：当前容器对外暴露的端口
• WORKDIR：在创建容器后，终端默认登录进来的工作目录，一个落脚点
• ENV：用来在构建镜像过程中设置环境变量，例如：ENV MY_PATH /tmp 其他地方使用$MY_PATH
• ADD：将主机的文件并解压，自动处理URL和tar
• COPY：类似ADD，但不解压 源路径（宿主机内）/目标路径（容器内）
• VOLUME：指定容器数据卷
• CMD：容器启动是要运行的命令
  • dockerfile可以有多个CMD，但只会有最后一个生效，会覆盖，如果在启动容器时指定了CMD，则会执行指定的CMD
  • 支持的格式
    • shell格式：CMD <命令>
    • exec格式：CMD["可执行文件"，"参数1"，"参数2"...]
• ENTRYPOINT：指定容器启动要运行的命令和CMD作用一样，但是不会覆盖，会追加，如果在启动容器时指定了CMD，追加指定的CMD 指定了ENTRYPOINT 就不会执行CMD
• ONBUILD：当构建一个被继承dockfile是运行命令，当子镜像被build时会触发父镜像的ONBUILD指令
• 

3、dockerfile案例

3.1、自定义mycentos

• 编写dockerfile

  • # 指定基础镜像
    FROM centos
    # 设置作者邮箱
    MAINTAINER ms<ms167@126.com>
    # 设置环境变量
    ENV MYPATH /use/local
    # 设置落脚点
    WORKDIR $MYPATH
    # 安装vim 和 ifconfig等命令 多个RUN 可以用&&连接只创建一个镜像层，否则一个RUN一个镜像层
    # RUN yum -y install vim
    # RUN yum -y install net-tools
    RUN yum -y install vim && yum -y install net-tools
    # 向外的暴露端口
    EXPOSE 80
    # 容器启动时执行的命令 只有最后一个生效
    CMD echo $MYPATH
    CMD echo "success"
    CMD /bin/bash
    

• 根据dockerfile构建镜像

  • 命令：docker build -f dockerfile路径 -t 镜像名:版本 .
    • 注意：-t 需要在 -f 之后，应该只能是最后一个参数
    • -f：指定dockerfile路径，不写默认当前路径寻找Dockerfile
    • .：最后一个点代表了上下文路径
      • 上下文路径，是指 docker 在构建镜像，有时候想要使用到本机的文件（比如复制），docker build 命令得知这个路径后，会将路径下的所有内容打包
      • 解析：由于 docker 的运行模式是 C/S。我们本机是 C，docker 引擎是 S。实际的构建过程是在 docker 引擎下完成的，所以这个时候无法用到我们本机的文件。这就需要把我们本机的指定目录下的文件一起打包提供给 docker 引擎使用
      • 如果未说明最后一个参数，那么默认上下文路径就是 Dockerfile 所在的位置
      • 注意：上下文路径下不要放无用的文件，因为会一起打包发送给 docker 引擎，如果文件过多会造成过程缓慢
  • 执行过程中报错Errors during downloading metadata for repository 'appstream':的解决方式
    • wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-8.repo
    • 清除缓存：yum clean all
    • 安装新依赖（缓存）：yum makecache
    • 重启docker(很重要)：systemctl restart docker
    • 重新构建即可

• 列出镜像的变更历史：docker history 镜像

3.2、CMD和ENTRYPOINT指令区别

CMD指令

• 为启动的容器指定默认要运行的程序，程序运行结束，容器也就结束，Dockerfile 中如果存在多个 CMD 指令，仅最后一个生效，CMD 指令指定的程序可被 docker run 命令行参数中指定要运行的程序所覆盖
• 格式
  • CMD <shell 命令>
  • CMD ["<可执行文件或命令>","","",...]
  • CMD ["","",...] # 该写法是为 ENTRYPOINT 指令指定的程序提供默认参数
  • 推荐使用第二种格式，执行过程比较明确。第一种格式实际上在运行的过程中也会自动转换成第二种格式运行，并且默认可执行文件是 sh

ENTRYPOINT指令

• 编写dockerfile

  • # 1.实际执行的是 curl -s https://ip.cn      curl命令可以下载网页的html -i参数下载头信息
    FROM centos
    CMD echo "success"
    ENTRYPOINT ["curl","-s","https://ip.cn"]
    # 即使启动时携带了CMD命令 还是会执行ENTRYPOINT
    
    # 2.实际执行的是 curl -s https://ip.cn 与CMD和ENTRYPOINT的顺序无关
    FROM centos
    ENTRYPOINT ["curl","-s","https://ip.cn"]
    CMD echo "success"
    
    # 3.实际执行的是 curl https://ip.cn 只有ENTRYPOINT后面最后一个CMD才能拼接到ENTRYPOINT指令上（后面有多个就覆盖） 前面的不行
    FROM centos
    CMD ["-i"]
    ENTRYPOINT ["curl"]
    CMD ["-s"]
    CMD ["https://ip.cn"]
    # 启动时携带了CMD命令 例如有 -i 实际执行的是 curl -i 就会报错（run 携带的参数也是一个CMD命令）
    
    # 4.实际执行的是curl -s https://ip.cn 如果有多个ENTRYPOINT 也只有最后一个生效
    FROM centos
    CMD ["-i"]
    ENTRYPOINT ["curl"]
    CMD ["-s"]
    CMD ["https://ip.cn"]
    ENTRYPOINT ["curl","-s","https://ip.cn"]
    # 启动时携带了CMD命令 例如有 -i 就会拼接 实际执行的是curl -s https://ip.cn -i
    
    # 5.如果ENTRYPOINT没有使用[] 形式 则不会追加 实际执行的是curl -s https://ip.cn
    FROM centos
    ENTRYPOINT curl -s https://ip.cn
    CMD ["-i"]
    

• 注意：如果有ENTRYPOINT存在，容器启动之后会优先执行ENTRYPOINT，不会执行CMD，如果没有ENTRYPOINT，则会执行最后一个CMD，与CMD和ENTRYPOINT的顺序无关

4、自定义tomcat

• 准备工作

  • 在目录下创建a.txt（用于测试COPY）
  • 上传apache-tomcat-8.5.61.tar.gz至该目录
  • 上传jdk-8u11-linux-x64.tar.gz至该目录

• 编写dockerfile

  • FROM centos
    MAINTAINER ms<ms167@126.com>
    # 把宿主机当前上下文的c.txt拷贝到容器/usr/local/路径下
    COPY a.txt /usr/local/cincontainer.txt
    # 把java与tomcat添加到容器中并解压 具体解压出来的目录是什么样子 要看tar.gz内部
    ADD jdk-8u11-linux-x64.tar.gz /usr/local/
    ADD apache-tomcat-8.5.61.tar.gz /usr/local/
    # 安装vim编辑器
    RUN yum -y install vim
    # 设置工作访问时候的WORKDIR路径，登录落脚点
    ENV MYPATH /usr/local
    WORKDIR $MYPATH
    # 配置java与tomcat环境变量 具体参照linux下配置 具体解压出来的目录名字 要看tar.gz内部
    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-8.5.61
    ENV CATALINA_BASE /usr/local/apache-tomcat-8.5.61
    ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
    #容器运行时监听的端口
    EXPOSE  8080
    # 启动时运行tomcat
    # ENTRYPOINT ["/usr/local/apache-tomcat-9.0.8/bin/startup.sh" ]
    # CMD ["/usr/local/apache-tomcat-9.0.8/bin/catalina.sh","run"]
    CMD /usr/local/apache-tomcat-8.5.61/bin/startup.sh && tail -F /usr/local/apache-tomcat-8.5.61/logs/catalina.out
    
    

• 构建镜像

  • docker build -f /test/mydocker/mytomcat8/Dockerfile -t mytomcat8:1.0 .

• 启动容器并创建数据卷 --privileged=true 解决 Docker挂载主机目录Docker访问出现cannot open directory .: Permission denied

  • docker run -it -P -v /test/mydocker/mytomcat8/tomcatwebapps:/usr/local/apache-tomcat-8.5.61/webapps -v /test/mydocker/mytomcat8/tomcatlog:/usr/local/apache-tomcat-8.5.61/logs --privileged=true mytomcat8:1.0

• 通过数据卷在宿主机中就可以修改容器中tomcat中的内容

5、ONBUILD指令

• ONBUILD指令用于子镜像被build时，父镜像触发

• 编写Dockerfile并构建镜像运行

  • # 1.父镜像
    FROM centos
    ONBUILD RUN echo "I'm parent-image"
    # docker build -f /test/mydocker/parent-children/parentfile -t parent-image .
    # 2.子镜像
    FROM parent-image
    CMD echo "I'm child-image"
    # docker build -f /test/mydocker/parent-children/childfile -t child-image .
    

• 构建子镜像时查看结果

  • [root@localhost parent-children]# docker build -f /test/mydocker/parent-children/childfile -t child-image .
    Sending build context to Docker daemon  3.072kB
    Step 1/2 : FROM parent-image
    
    此处说明了执行了一个触发器 也就是父镜像中ONBUILD指令
    # Executing 1 build trigger
     ---> Running in 49d2db5530c2
    I'm parent-image
    
    Removing intermediate container 49d2db5530c2
     ---> 184b598876a3
    Step 2/2 : CMD echo "I'm child-image"
     ---> Running in 6b6359d232c3
    Removing intermediate container 6b6359d232c3
     ---> ca71e2df6c07
    Successfully built ca71e2df6c07
    Successfully tagged child-image:latest
    

六、常用软件的安装

• docker软件安装流程
  • 搜索镜像
  • 拉取镜像
  • 查看镜像
  • 启动容器
  • 停止容器
  • 移除容器

1、安装tomcat

• 上面已经安装过，此处省略

2、安装mysql

• 拉取mysql5.7.20镜像
• 启动容器
  • docker run -p 12345:3306 --name mysql -v /test/mysql/conf:/etc/mysql/mysql.conf.d -v /test/mysql/logs:/logs -v /test/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7.20
  • 命令说明：
    • -p 12345:3306：将主机的12345端口映射到docker容器的3306端口。
    • --name mysql：运行容器的名字
    • -v /test/mysql/conf:/etc/mysql/mysql.conf.d ：将主机/test/mysql/conf目录挂载到容器的/etc/mysql/conf.d或者mysql.conf.d（这两个目录根据版本的不同而不同，里面的mysqld.cnf为mysql的配置文件）
    • -v /test/mysql/logs:/logs：将主机/test/mysql目录下的logs目录挂载到容器的/logs。
    • -v /test/mysql/data:/var/lib/mysql ：将主机/test/mysql目录下的data目录挂载到容器的/var/lib/mysql 也就是mysql的data目录
    • -e MYSQL_ROOT_PASSWORD=123456：初始化root用户的密码。
    • -d mysql:5.7.20 : 后台程序运行mysql:5.7.20
• 在容器外面连接即可

3、安装redis

• 拉取redis3.2镜像
• 编写配置文件并放入自己创建的目录下（启动时需要对应数据卷）
  • 在该目录/test/redis/conf下创建redis.conf
  • 将官网上的配置文件内容写入，将bind注释掉
  • 在docker中启动redis一定要把：daemonize 设置为 no，这个很重要，如果不是no docker会一直启动失败，原因是docker本身需要后台运行，而这个配置选项也是以守护进程启动，两者会冲突
    • 不设置也可以
• 启动容器
  • docker run -p 6379:6379 -v /test/redis/data:/data -v /test/redis/conf:/usr/local/etc/redis/conf -d redis:3.2 redis-server /usr/local/etc/redis/conf --appendonly yes
  • 命令说明
    • -v /test/redis/data:/data ：持久化文件存储的地方
    • -v /test/redis/conf:/usr/local/etc/redis/conf ：配置文件存放的地方
    • redis-server /usr/local/etc/redis/conf ：指定配置文件启动
    • --appendonly yes ：开启持久化
• 在容器外面连接即可

七、将镜像推至阿里云

• 推送拉取流程

  • 

• 在阿里云镜像仓库创建仓库

  • 以下具体地址在阿里云镜像仓库查看

• 在linux中登录阿里云镜像仓库

  • sudo docker login --username=xxxxxx registry.cn-hangzhou.aliyuncs.com

• 在linux推送镜像至仓库

  • sudo docker tag [ImageId] 仓库地址:[镜像版本号]
  • sudo docker push 仓库地址:[镜像版本号]
  • 注意：这两个[镜像版本号]要保持一致

• 推送成功后可拉取到本地

  • sudo docker pull 仓库地址:[镜像版本号]