编程知识 cdmana.com

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一次构建、随处运行
      • 更快速的应用交付和部署
      • 更便捷的升级和扩缩容
      • 更简单的系统运维
      • 更高效的计算资源利用
  • 相关网站

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解决方式
    • 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
开机自启
  • 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 仓库地址:[镜像版本号]

版权声明
本文为[xiaokantianse]所创,转载请带上原文链接,感谢
https://www.cnblogs.com/xiaokantianse/p/14183041.html

Scroll to Top