Cris 的 Docker 学习笔记

Author:Cris

1. Docker 基础知识

1.1 什么是 Docker ?

这里引用维基百科

Docker是一个开放源代码软件项目，让应用程序部署在软件货柜下的工作可以自动化进行，借此在Linux操作系统上，提供一个额外的软件抽象层，以及操作系统层虚拟化的自动管理机制

依据行业分析公司“451研究”：“Dockers是有能力打包应用程序及其虚拟容器，可以在任何Linux服务器上运行的依赖性工具，这有助于实现灵活性和便携性，应用程序在任何地方都可以运行，无论是公有云、私有云、单机等。”

中文官网地址

简单来说,Docker 通过对应用组件的封装、分发、部署、运行等生命周期的管理，使用户的APP（可以是一个WEB应用或数据库应用等等）及其运行环境能够做到“一次封装，到处运行”。

1.2 为什么 Docker 如此流行?

一款产品从开发到上线，从操作系统，到运行环境，再到应用配置。作为开发+运维之间的协作我们需要关心很多东西，这也是很多互联网公司都不得不面对的问题，特别是各种版本的迭代之后，不同版本环境的兼容，对运维人员都是考验

Docker之所以发展如此迅速，也是因为它对此给出了一个标准化的解决方案。

环境配置如此麻烦，换一台机器，就要重来一次，费力费时。很多人想到，能不能从根本上解决问题，软件可以带环境安装？也就是说，安装的时候，把原始环境一模一样地复制过来。开发人员利用 Docker 可以消除协作编码时“在我的机器上可正常工作”的问题。

之前在服务器配置一个应用的运行环境，要安装各种软件，随便拿一个 Java 项目来说，Java/Tomcat/MySQL/JDBC驱动包基本是必不可少的。安装和配置这些东西有多麻烦就不说了，它还不能跨平台。假如我们是在 Windows 上安装的这些环境，到了 Linux 又得重新装。况且就算不跨操作系统，换另一台同样操作系统的服务器，要移植应用也是非常麻烦的。

传统上认为，软件编码开发/测试结束后，所产出的成果即是程序或是能够编译执行的二进制字节码等(java为例)。而为了让这些程序可以顺利执行，开发团队也得准备完整的部署文件，让维运团队得以部署应用程式，开发需要清楚的告诉运维部署团队，用的全部配置文件+所有软件环境。不过，即便如此，仍然常常发生部署失败的状况。

Docker镜像的设计，使得Docker得以打破过去「程序即应用」的观念。透过镜像(images)将作业系统核心除外，运作应用程式所需要的系统环境，由下而上打包，达到应用程式跨平台间的无缝接轨运作。

1.3 Docker 的理念

Docker是基于Go语言实现的云开源项目。

Docker的主要目标是“Build，Ship and Run Any App,Anywhere”，也就是通过对应用组件的封装、分发、部署、运行等生命周期的管理，使用户的APP（可以是一个WEB应用或数据库应用等等）及其运行环境能够做到“一次封装，到处运行”。

Linux 容器技术的出现就解决了这样一个问题，而 Docker 就是在它的基础上发展过来的。将应用运行在 Docker 容器上面，而 Docker 容器在任何操作系统上都是一致的，这就实现了跨平台、跨服务器。只需要一次配置好环境，换到别的机子上就可以一键部署好，大大简化了操作(可以参考一下 Java 的一次编译,处处运行特性)

简单来说,Docker 的出现解决了运行环境和配置问题软件容器，方便做持续集成并有助于整体发布的容器虚拟化技术

1.4 Docker 虚拟化

首先我们简单了解一下 Docker 的实现原理

虚拟机技术

虚拟机（virtual machine）就是带环境安装的一种解决方案。它可以在一种操作系统里面运行另一种操作系统，比如在Windows 系统里面运行Linux 系统。应用程序对此毫无感知，因为虚拟机看上去跟真实系统一模一样，而对于底层系统来说，虚拟机就是一个普通文件，不需要了就删掉，对其他部分毫无影响。这类虚拟机完美的运行了另一套系统，能够使应用程序，操作系统和硬件三者之间的逻辑不变。

虚拟机的缺点：
1. 资源占用多
2. 冗余步骤多
3. 启动慢
容器虚拟化技术

由于前面虚拟机存在这些缺点，Linux 发展出了另一种虚拟化技术：Linux 容器（Linux Containers，缩写为 LXC）。 Linux 容器不是模拟一个完整的操作系统，而是对进程进行隔离。有了容器，就可以将软件运行所需的所有资源打包到一个隔离的容器中。容器与虚拟机不同，不需要捆绑一整套操作系统，只需要软件工作所需的库资源和设置。系统因此而变得高效轻量并保证部署在任何环境中的软件都能始终如一地运行。

比较 Docker 和传统虚拟化方式的不同之处：

传统虚拟机技术是虚拟出一套硬件后，在其上运行一个完整操作系统，在该系统上再运行所需应用进程；
而容器内的应用进程直接运行于宿主的内核，容器内没有自己的内核，而且也没有进行硬件虚拟。因此容器要比传统虚拟机更为轻便。

每个容器之间互相隔离，每个容器有自己的文件系统，容器之间进程不会相互影响，能区分计算资源。

1.5 DevOps

通过 Docker 一次构建,处处运行的特性, DevOps 得到了极大的发展, 关于 DevOps,可以参考知乎的这个问答

或者这个系列的文章

个人理解: DevOps 是一种优化软件开发和运营部署之间理念,通过自动化的工具协作和沟通来完成软件的生命周期管理，从而更快、更频繁地交付更稳定的软件

1.6 Docker 的优势

更快速的应用交付和部署

传统的应用开发完成后，需要提供一堆安装程序和配置说明文档，安装部署后需根据配置文档进行繁杂的配置才能正常运行。Docker化之后只需要交付少量容器镜像文件，在正式生产环境加载镜像并运行即可，应用安装配置在镜像里已经内置好，大大节省部署配置和测试验证时间。
更便捷的升级和扩缩容

随着微服务架构和Docker的发展，大量的应用会通过微服务方式架构，应用的开发构建将变成搭乐高积木一样，每个Docker容器将变成一块“积木”，应用的升级将变得非常容易。当现有的容器不足以支撑业务处理时，可通过镜像运行新的容器进行快速扩容，使应用系统的扩容从原先的天级变成分钟级甚至秒级。
更简单的系统运维

应用容器化运行后，生产环境运行的应用可与开发、测试环境的应用高度一致，容器会将应用程序相关的环境和状态完全封装起来，不会因为底层基础架构和操作系统的不一致性给应用带来影响，产生新的BUG。当出现程序异常时，也可以通过测试环境的相同容器进行快速定位和修复。
更高效的计算资源利用

Docker是内核级虚拟化，其不像传统的虚拟化技术一样需要额外的Hypervisor支持，所以在一台物理机上可以运行很多个容器实例，可大大提升物理服务器的CPU和内存的利用率。

1.7 当前企业使用 Docker 现状

美团
微博
蘑菇街

ps: 如果软件开发人员对自动化运维同样熟悉,那么不仅可以大大降低开发和运维之间的扯皮,还可以提高开发人员的议价能力

1.8 Docker 官网和仓库

docker官网：www.docker.com

docker中文网站：www.docker-cn.com/

Docker Hub官网: hub.docker.com/

1.9 个人总结

以 Java 为例,以前开发人员只需要将开发好的代码交给运维部署即可,但是随着敏捷开发等开发模式的流行以及越来越高速化的软件开发-测试-交付-部署等流程,为了减低运维压力,调和开发人员和运维人员之间的关系,容器虚拟化技术(Docker)的应运而生

以前我们仅仅是是将 Java 代码进行交付,现在我们是将开发环境整套进行交付.通过对开发环境(例如 Redis, MySQL 以及各种配置等)和开发代码打包,不仅更加快速,便捷,也很容易的对应用部署进行弹性扩容,也大大减少了运维压力

类似于搬家,为了营造一个和之前一样的生活环境,的我们还需要将旧家的东西搬运到新家去,假如有一天,你很有钱,可以将旧家所在的整栋楼搬运到新家所在地;或者说你有了超能力,可以将旧家的环境直接复制到新家.那么比起以前累死累活的搬运东西这种方式,哪个更方便不就是一目了然的事情了~~~

2. Docker 安装

2.1 前提

当前 Docker 基本都装在 Linux 环境下,以 CentOS 为例,建议 CentOS6.5 以上版本,目前主流 CentOS6.8 和 CentOS7.x 都支持

Cris 的 Linux 环境如下

2.2 Docker 三要素

镜像(Image)

Docker 镜像（Image）就是一个只读的模板。镜像可以用来创建 Docker 容器，一个镜像可以创建很多容器。
容器(Container)

Docker 利用容器（Container）独立运行一个或一组应用。容器是用镜像创建的运行实例。

它可以被启动、开始、停止、删除。每个容器都是相互隔离的、保证安全的平台。

可以把容器看做是一个简易版的 Linux 环境（包括root用户权限、进程空间、用户空间和网络空间等）和运行在其中的应用程序。

容器的定义和镜像几乎一模一样，也是一堆层的统一视角，唯一区别在于容器的最上面那一层是可读可写的。
仓库（Repository）

仓库（Repository）是集中存放镜像文件的场所。

仓库(Repository)和仓库注册服务器（Registry）是有区别的。仓库注册服务器上往往存放着多个仓库，每个仓库中又包含了多个镜像，每个镜像有不同的标签（tag）。

仓库分为公开仓库（Public）和私有仓库（Private）两种形式。最大的公开仓库是 Docker Hub(hub.docker.com/)，存放了数量庞大的镜像供用户下载。国内的公开仓库包括阿里云、网易云等

需要正确的理解仓储/镜像/容器这几个概念:

Docker 本身是一个容器运行载体或称之为管理引擎。我们把应用程序和配置依赖打包好形成一个可交付的运行环境，这个打包好的运行环境就是 image镜像文件。只有通过这个镜像文件才能生成容器。image 文件可以看作是容器的模板。Docker 根据 image 文件生成容器的实例。同一个 image 文件，可以生成多个同时运行的容器实例。

image 文件生成容器实例，称为镜像文件。

一个容器运行一种服务，当我们需要的时候，就可以通过docker客户端创建一个对应的运行实例，也就是我们的容器

至于仓储，就是放了一堆镜像的地方，我们可以把镜像发布到仓储中，需要的时候从仓储中拉下来就可以了。

Docker 简易流程图

2.3 安装 Docker

以 Cris 的CentOS6.8 为例

Docker使用EPEL发布，RHEL系的OS首先要确保已经持有EPEL仓库，否则先检查OS的版本，然后安装相应的EPEL包。
```
[cris@hadoop104 ~]$ sudo yum install -y epel-release
复制代码
```

然后执行 Docker 安装命令

当前在 CentOS6.8 版本如果直接执行以下命令,很可能无法安装 Docker

[cris@hadoop104 ~]$ sudo yum install -y docker-io
复制代码

所以需要执行另外的命令

[root@hadoop104 cris]# yum install https://get.docker.com/rpm/1.7.1/centos-6/RPMS/x86_64/docker-engine-1.7.1-1.el6.x86_64.rpm
复制代码

参考博客

安装后的配置文件：/etc/sysconfig/docker
Docker 版本
启动 Docker

ps: 如果要在 CentOS7.x 上安装 Docker, 请直接参考官网文档即可

2.4 Docker 镜像加速

以阿里云为例,首先注册一个阿里云账号,然后进入镜像加速页面

配置本机的 Docker 文件

[cris@hadoop104 ~]$ sudo vim /etc/sysconfig/docker
复制代码

重启 Docker 服务

[cris@hadoop104 ~]$ sudo service docker restart
停止 docker：                                              [确定]
Starting docker:	                                   [确定]
复制代码

然后检测 Docker 镜像加速地址是否是我们的阿里云镜像地址

ps: 如果是 CentOS7.x 版本,直接参考上面的阿里云操作文档

网易云镜像加速这里直接略过~~~:cowboy_hat_face:

2.5 hello world

直接通过 docker run hello-world 命令,我们可以直接从阿里云拉取 hello-world 镜像并创建容器自动运行(在本地没有找到 hello-world 的镜像时)

docker run 命令运行流程图

2.6 Docker 和 VM 比较

Docker 工作原理

Docker是一个Client-Server结构的系统，Docker守护进程运行在主机上，然后通过Socket连接从客户端访问，守护进程从客户端接受命令并管理运行在主机上的容器。容器，是一个运行时环境，就是我们前面说到的集装箱。

例如下面 Docker 图标(一只鲸鱼背上拖着很多个集装箱, 鲸鱼类似于 Docker,一个个的集装箱就是软件开发环境中的各种软件)

以下为 Docker 运行架构图

为什么 Docker 运行速度远大于 VM?

(1)Docker有着比虚拟机更少的抽象层。由于docker不需要Hypervisor实现硬件资源虚拟化,运行在docker容器上的程序直接使用的都是实际物理机的硬件资源。因此在CPU、内存利用率上docker将会在效率上有明显优势。

(2)Docker利用的是宿主机的内核,而不需要CentOS。因此,当新建一个容器时,docker不需要和虚拟机一样重新加载一个操作系统内核。从而避免加载操作系统内核这个比较费时费资源的过程,当新建一个虚拟机时,虚拟机软件需要加载CentOS,整个新建过程是分钟级别的。而docker由于直接利用宿主机的操作系统,因此新建一个docker容器只需要几秒钟。
Docker 和 VM 对比图

Docker 和 VM 特点对比图

3. Docker 常用命令

3.1 帮助命令

docker version
docker info
docker --help(-h)

3.2 镜像命令

docker images

列出本地主机上的镜像

REPOSITORY：表示镜像的仓库源
TAG：镜像的标签
MAGE ID：镜像ID
CREATED：镜像创建时间
SIZE：镜像大小

同一仓库源可以有多个 TAG，代表这个仓库源的不同个版本，我们使用 REPOSITORY:TAG 来定义不同的镜像。如果你不指定一个镜像的版本标签，例如你只使用 ubuntu，docker 将默认使用 ubuntu:latest 镜像

images 命令的 option 参数
- -a:列出本地所有的镜像（含中间映像层）
- -q :只显示镜像ID
- --digests :显示镜像的摘要信息
- --no-trunc :显示完整的镜像信息

docker search 镜像名

从 Docker hub 官网搜索镜像

官网地址: hub.docker.com

以 tomcat 为例

和在官网搜索的结果一模一样

参数说明
- -s : 列出收藏数不小于指定值的镜像
  
  只搜索点赞数大于30的镜像
- --no-trunc : 显示完整的镜像描述
- --automated : 只列出 automated build类型的镜像

docker pull 镜像名:tag

拉取镜像(从前面我们已经设置的阿里云的镜像加速地址)

如果 docker pull 镜像名 后面不加参数,默认下载最新版本

即 docker pull tomcat 等价于 docker pull tomcat:latest
```
[cris@hadoop104 ~]$ sudo docker pull tomcat
复制代码
```
docker rmi 镜像名/镜像id

删除 Docker 镜像

ps: docker rmi 镜像名 默认会删除标签为 :latest 的镜像,如果要删除指定标签的镜像,在镜像名后面指定 tag 即可

如果无法删除,出现如上提示,表示我们的镜像正在使用中,可以使用 -f 强制删除

如果想要删除多个镜像

docker rmi -f 镜像名1:tag 镜像名2:tag
```
sudo docker rmi -f hello-world tomcat
复制代码
```
删除全部镜像
```
sudo docker rmi -f $(docker images -qa)
复制代码
```

结合 git 知识,想想 Docker 是否有 docker pull 和 docker commit 命令?

3.3 容器命令

以 CentOS 为例,这里 Cris 从阿里云下载一个 CentOS 的镜像
新建并启动容器(以 Docker 里面的 CentOS 镜像为例)

docker run [options] image [command] [arg...]

options 这里常用的有:

--name="容器新名字": 为容器指定一个名称； -d: 后台运行容器，并返回容器ID，也即启动守护式容器； -i：以交互模式运行容器，通常与 -t 同时使用； -t：为容器重新分配一个伪输入终端，通常与 -i 同时使用； -P: 随机端口映射； -p: 指定端口映射，有以下四种格式 ip:hostPort:containerPort ip::containerPort hostPort:containerPort containerPort

我们使用 -it 参数来启动 CentOS 容器

root@ 后面跟着的就是该容器的 id
查看所有运行的容器命令

docker ps [options]

参数说明:

-a :列出当前所有正在运行的容器+历史上运行过的容器 -l :显示最近运行的容器。 -n number：显示最近 number 个创建的容器。 -q :静默模式，只显示容器编号。 --no-trunc :不截断输出。
退出容器

exit: 容器停止并退出

ctrl+p+q: 容器不停止退出
启动已经创建的容器

docker start 容器id/容器名
重启容器

docker restart 容器id/容器名
停止容器

docker stop 容器id/容器名
强制关闭容器

docker kill 容器id/容器名
删除已停止的容器

docker rm 容器id/容器名

一次性删除多个已经停止的容器

docker rm -f $(docker ps -qa) 或者 docker ps -a -q | xargs docker rm
交互式容器和守护式容器

前面启动 CentOS 容器使用的 -it 参数就是表示交互式命令,通过终端来保持和容器的交互

如果要启动守护式容器,那么需要加上 -d 参数

但是此时查询正在运行的容器

没有发现以后台模式运行的 Docker 容器

发现该容器已经自动退出了

问题：docker ps -a 进行查看, 会发现容器已经退出很重要的一点: Docker容器后台运行,就必须有一个前台进程. 容器运行的命令如果不是那些一直挂起的命令（比如运行top，tail），是会自动退出的。

这个是docker的机制问题,比如你的web容器,我们以nginx为例，正常情况下,我们配置启动服务只需要启动响应的service即可。例如 service nginx start 但是,这样做,nginx为后台进程模式运行,就导致docker前台没有运行的应用, 这样的容器后台启动后,会立即自杀因为他觉得他没事可做了. 所以，最佳的解决方案是,将你要运行的程序以前台进程的形式运行
容器日志

对于后台运行的容器,可以以下面的方式来启动
```
[cris@hadoop104 ~]$ sudo  docker run -d --name centos004 centos /bin/sh -c "while true;do echo hello zzyy;sleep 2;done"
复制代码
```
查看 Docker 容器

即便是后台启动,但是因为前台一直打印日志,Docker 容器也不会自动关闭

如果此时我们想去查看 Docker 容器的日志,可以通过以下命令

docker logs -f -t --tail 容器ID
- -t 是加入时间戳
- -f 跟随最新的日志打印
- --tail 数字显示最后多少条
查看容器内运行的进程

docker top 容器ID
查看容器内部细节

docker inspect 容器ID
进入正在运行的容器并以命令行交互

重新进入正在运行的容器

docker attach 容器ID

还有一种方式是

docker exec -it 容器ID bashShell(功能更加强大,可以直接返回结果到客户端)

区别在于:

attach 命令直接进入容器启动命令的终端，不会启动新的进程

exec 命令是在容器中打开新的终端，并且可以启动新的进程
从容器内拷贝文件到主机上

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

示例如下

3.4 常用命令总结

attach    Attach to a running container                 # 当前 shell 下 attach 连接指定运行镜像

build     Build an image from a Dockerfile              # 通过 Dockerfile 定制镜像

commit    Create a new image from a container changes   # 提交当前容器为新的镜像

cp        Copy files/folders from the containers filesystem to the host path   #从容器中拷贝指定文件或者目录到宿主机中

create    Create a new container                        # 创建一个新的容器，同 run，但不启动容器

diff      Inspect changes on a container's filesystem   # 查看 docker 容器变化

events    Get real time events from the server          # 从 docker 服务获取容器实时事件

exec      Run a command in an existing container        # 在已存在的容器上运行命令

export    Stream the contents of a container as a tar archive   # 导出容器的内容流作为一个 tar 归档文件[对应 import ]

history   Show the history of an image                  # 展示一个镜像形成历史

images    List images                                   # 列出系统当前镜像

import    Create a new filesystem image from the contents of a tarball # 从tar包中的内容创建一个新的文件系统映像[对应export]

info      Display system-wide information               # 显示系统相关信息

inspect   Return low-level information on a container   # 查看容器详细信息

kill      Kill a running container                      # kill 指定 docker 容器

load      Load an image from a tar archive              # 从一个 tar 包中加载一个镜像[对应 save]

login     Register or Login to the docker registry server    # 注册或者登陆一个 docker 源服务器

logout    Log out from a Docker registry server          # 从当前 Docker registry 退出

logs      Fetch the logs of a container                 # 输出当前容器日志信息

port      Lookup the public-facing port which is NAT-ed to PRIVATE_PORT    # 查看映射端口对应的容器内部源端口

pause     Pause all processes within a container        # 暂停容器

ps        List containers                               # 列出容器列表

pull      Pull an image or a repository from the docker registry server   # 从docker镜像源服务器拉取指定镜像或者库镜像

push      Push an image or a repository to the docker registry server    # 推送指定镜像或者库镜像至docker源服务器

restart   Restart a running container                   # 重启运行的容器

rm        Remove one or more containers                 # 移除一个或者多个容器

rmi       Remove one or more images             # 移除一个或多个镜像[无容器使用该镜像才可删除，否则需删除相关容器才可继续或 -f 强制删除]

run       Run a command in a new container              # 创建一个新的容器并运行一个命令

save      Save an image to a tar archive                # 保存一个镜像为一个 tar 包[对应 

load]

search    Search for an image on the Docker Hub         # 在 docker hub 中搜索镜像

start     Start a stopped containers                    # 启动容器

stop      Stop a running containers                     # 停止容器

tag       Tag an image into a repository                # 给源中镜像打标签

top       Lookup the running processes of a container   # 查看容器中运行的进程信息

unpause   Unpause a paused container                    # 取消暂停容器

version   Show the docker version information           # 查看 docker 版本号

wait      Block until a container stops, then print its exit code   # 截取容器停止时的退出状态值
复制代码

4. Docker 镜像

镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发，它包含运行某个软件所需的所有内容，包括代码、运行时、库、环境变量和配置文件。

而 Docker 镜像的底层实现原理是 UnionFS 联合文件系统

4.1 UnionFS 联合文件系统

UnionFS（联合文件系统）：Union文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。Union 文件系统是 Docker 镜像的基础。镜像可以通过分层来进行继承，基于基础镜像（没有父镜像），可以制作各种具体的应用镜像。

类似于花卷这种常见的早餐,文件系统可以通过一层一层的嵌套,对外暴露统一的"表面层"来供使用者操作

特性：一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录

4.2 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 pull 命令再来感受一下镜像分层

所以在下载的过程中我们可以看到docker的镜像好像是在一层一层的在下载

为什么 Docker 镜像要采用这种分层结构呢?

最大的一个好处就是 - 共享资源

比如：有多个镜像都从相同的 base 镜像构建而来，那么宿主机只需在磁盘上保存一份base镜像，同时内存中也只需加载一份 base 镜像，就可以为所有容器服务了。而且镜像的每一层都可以被共享。

所以,Docker镜像都是只读的,当容器启动时，一个新的可写层被加载到镜像的顶部。这一层通常被称作“容器层”，“容器层”之下的都叫“镜像层”。

4.3 Docker 镜像 commit 操作

基础命令

docker commit 用于提交容器副本使之成为一个新的镜像

完整格式如下

docker commit -m=“提交的描述信息” -a=“作者” 容器ID 要创建的目标镜像名:[标签名]

以 Tomcat 为例

启动 Tomcat 容器

-p 主机端口:docker容器端口
-P 随机分配主机端口
i:交互
t:终端

以交互模式进入到 Docker 中的 Tomcat 中

[cris@hadoop104 ~]$ sudo docker exec -it 8db42f30a60a /bin/bash
root@8db42f30a60a:/usr/local/tomcat# 
复制代码

我们删除掉 tomcat 下的 doc 文档

也即当前的tomcat运行实例是一个没有文档内容的容器，以它为模板commit一个没有doc的tomcat新镜像 cris/tomcat

至此,新的没有 doc 的 Tomcat 镜像已经生成好了
运行基于新镜像的 Tomcat 容器
```
[cris@hadoop104 ~]$ sudo docker run -it -p 8118:8080 cris/tomcat:1.1
复制代码
```
可以发现是没有 doc 文档的

ps: 以上都是以前台方式启动 Tomcat 容器(不断打印日志),如果想要以后台守护方式启动,直接加上 -d 参数即可

控制台也就没有日志打印了

5. Docker容器数据卷

5.1 什么是 Docker 容器数据卷

需求:

Docker 可以将运行的环境打包形成容器运行，但是我们对 Docker 容器的数据的要求希望是持久化的
容器之间希望共享数据

Docker容器产生的数据，如果不通过docker commit生成新的镜像，使得数据做为镜像的一部分保存下来，那么当容器删除后，数据自然也就没有了。

为了能保存数据在docker中我们使用数据卷。

类似 Redis里面的rdb和aof文件或者我们平时使用的移动硬盘

5.2 数据卷的用处

数据卷就是目录或文件，存在于一个或多个容器中，由docker挂载到容器，但不属于联合文件系统，因此能够绕过Union File System提供一些用于持续存储或共享数据的特性：

数据卷的设计目的就是数据的持久化，完全独立于容器的生存周期，因此Docker不会在容器删除时删除其挂载的数据卷

特点：

数据卷可在容器之间共享或重用数据
卷中的更改可以直接生效
数据卷中的更改不会包含在镜像的更新中
数据卷的生命周期一直持续到没有容器使用它为止

5.3 数据卷使用

一. 直接通过命令添加数据卷

docker run -it -v /宿主机绝对路径目录:/容器内目录镜像名

验证数据卷是否挂载成功

[cris@hadoop104 ~]$ sudo docker inspect 4b02b2727058
复制代码

宿主机和容器之间的数据交互

同理, 容器可以对数据进行修改并同步到宿主机

容器停止退出后，主机修改后数据是否同步

通过 exit 命令停止容器并退出终端

然后在宿主机对数据进行修改

[cris@hadoop104 hostDataVolume]$ sudo vim dog.txt
复制代码

重新开启容器

可以发现,即便是容器关闭,宿主机依然可以对数据卷进行数据操作,当容器重新开启时,数据卷会自动进行同步

如果想要设置权限,例如容器只能对数据卷进行读和同步,宿主机可以操作数据卷,那么只需要添加一个参数即可

docker run -it -v /宿主机绝对路径目录:/容器内目录:ro 镜像名

ro 就表示 read-only 权限(针对容器)

二. DockerFile添加数据卷

DockerFile 简单来说,就是描述 Docker 镜像的描述文件

流程简单梳理如下

宿主机新建一个 DockerFile

可在Dockerfile中使用VOLUME指令来给镜像添加一个或多个数据卷

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

测试数据卷

根据 inspect 命令查看对应的宿主机数据卷目录

[cris@hadoop104 ~]$ sudo docker ps
CONTAINER ID        IMAGE               COMMAND                CREATED             STATUS              PORTS               NAMES
cd98e9b2c94b        cris/centos         "/bin/sh -c /bin/bas   2 minutes ago       Up 2 minutes                            jovial_goodall      
[cris@hadoop104 ~]$ sudo docker inspect cd98e9b2c94b
复制代码

默认宿主机挂载地址需要通过 inspect 命令查看

三. 数据卷容器

主要用于容器和容器之间的数据共享

命令: --volumes-from

示例如下:

启动一个父容器

启动后我们在指定目录下创建一个文件
新建两个子容器,继承自父容器

可以发现成功同步了父容器的数据

同时修改任意一个子容器的数据卷数据,都会同步到其他容器

即便是删除任意一个容器,数据卷的数据同步不会停止
结论

容器之间共享数据的传递，数据卷的生命周期一直持续到没有容器使用它为止

6. DockerFile解析

6.1 什么是 DockerFile

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

通常使用 DockerFile 的三个步骤都是:

编写 DockerFile 文件
执行 docker build 编译命令
执行docker run 启动容器命令

以 CentOS 为例, Docker Hub 上的 CentOS 的 DockerFile 文件如下

6.2 DockerFile 构建过程解析

DockerFile 基础知识

以上面的 CentOS DockerFile 文件为例

每条保留字指令(红色字体)都必须为大写字母且后面要跟随至少一个参数
指令按照从上到下，顺序执行
#表示注释
每条指令都会创建一个新的镜像层，并对镜像进行提交

Docker执行Dockerfile的大致流程

docker从基础镜像运行一个容器
执行一条指令并对容器作出修改
执行类似docker commit的操作提交一个新的镜像层
docker再基于刚提交的镜像运行一个新容器
执行dockerfile中的下一条指令直到所有指令都执行完成

总结:

从应用软件的角度来看，Dockerfile、Docker镜像与Docker容器分别代表软件的三个不同阶段，

Dockerfile是软件的原材料
Docker镜像是软件的交付品
Docker容器则可以认为是软件的运行态。 Dockerfile面向开发，Docker镜像成为交付标准，Docker容器则涉及部署与运维，三者缺一不可，合力充当Docker体系的基石。

Dockerfile，需要定义一个Dockerfile，Dockerfile定义了进程需要的一切东西。Dockerfile涉及的内容包括执行代码或者是文件、环境变量、依赖包、运行时环境、动态链接库、操作系统的发行版、服务进程和内核进程(当应用进程需要和系统服务和内核进程打交道，这时需要考虑如何设计namespace的权限控制)等等;

Docker镜像，在用Dockerfile定义一个文件之后，docker build时会产生一个Docker镜像，当运行 Docker镜像时，会真正开始提供服务;

Docker容器，直接提供服务.

6.3 DockerFile 体系结构(保留字)

FROM : 基础镜像，当前新镜像是基于哪个镜像的
MAINTAINER : 镜像维护者的姓名和邮箱地址
RUN : 容器构建时需要运行的命令
EXPOSE : 当前容器对外暴露出的端口
WORKDIR : 指定在创建容器后，终端默认登陆的进来工作目录，一个落脚点
ENV : 用来在构建镜像过程中设置环境变量

ENV MY_PATH /usr/mytest 这个环境变量可以在后续的任何RUN指令中使用，这就如同在命令前面指定了环境变量前缀一样；也可以在其它指令中直接使用这些环境变量，

比如：WORKDIR $MY_PATH
ADD : 将宿主机目录下的文件拷贝进镜像且ADD命令会自动处理URL和解压tar压缩包
COPY : 类似ADD，拷贝文件和目录到镜像中。将从构建上下文目录中 <源路径> 的文件/目录复制到新的一层的镜像内的 <目标路径> 位置
VOLUME : 容器数据卷，用于数据保存和持久化工作
CMD : 指定一个容器启动时要运行的命令

注意: Dockerfile 中可以有多个 CMD 指令，但只有最后一个生效，CMD 会被 docker run 之后的参数替换
ENTRYPOINT : 指定一个容器启动时要运行的命令;ENTRYPOINT 的目的和 CMD 一样，都是在指定容器启动程序及参数,但是不会被 docker run 后面的参数替换,而是追加
ONBUILD : 当构建一个被继承的Dockerfile时运行命令，父镜像在被子继承后父镜像的onbuild被触发

总结:

6.4 DockerFile 实战案例

一. 自定义 CentOS 镜像案例

首先,我们需要知道Docker Hub 中 99% 的镜像都是通过在 base 镜像中安装和配置需要的软件构建出来的

而这个 base 镜像就是scratch 镜像

首先停止所有正在运行的 Docker 容器

然后看看从阿里云下载的基础版 CentOS 缺失了哪些功能

现在我们的目标就是通过编写 DockerFile 为基础版本的 CentOS 镜像加上这些缺失的功能

DockerFile 如下

FROM centos
MAINTAINER cris
 
ENV MYPATH /usr/local
WORKDIR $MYPATH
 
RUN yum -y install vim
RUN yum -y install net-tools
 
EXPOSE 80
 
CMD echo $MYPATH
CMD echo "success--------------ok"
CMD /bin/bash
复制代码

开始构建

[cris@hadoop104 dockerFile]$ sudo docker build -f centosDockerFile -t cris/centos:1.2 .
复制代码

构建成功,开始运行容器

除此之外,还可以查看 Docker 镜像的修改历史

二. CMD/ENTRYPOINT 镜像案例

CMD 示例:

Dockerfile 中可以有多个 CMD 指令，但只有最后一个生效，CMD 会被 docker run 之后的参数替换

以 Tomcat 为例

原因就在于我们的 ls -l 参数替换掉了原来的启动参数,如下

相当于在这行参数后面又添加了 CMD ls -l

那么容器启动时就会执行最后的 ls -l 命令

如果是 ENTRYPOINT

docker run 之后的参数会被当做参数传递给 ENTRYPOINT，之后形成新的命令组合

示例如下

编写 DockerFile

FROM centos
RUN yum install -y curl
ENTRYPOINT [ "curl", "-s", "http://ip.cn" ]
复制代码

然后构建

[cris@hadoop104 dockerFile]$ sudo docker build -f centosDockerFile2 -t cris/ipcentos .
复制代码

以添加参数的形式启动容器

如果我们把上面 DockerFile 文件中的 ENTRYPOINT 改为 CMD 并重新编译镜像

那么同样的命令启动容器,会出现以下报错

ONBUILD 示例

类似于触发器,在镜像编译以及子镜像编译的时候触发

新建一个 DockerFile , centosDockerFileFather

FROM centos
RUN yum install -y curl
ENTRYPOINT [ "curl", "-s", "http://ip.cn" ]
ONBUILD RUN echo "father is building -------------->"
复制代码

进行编译后,又新建一个子 DockerFile, centosDockerFileSon

FROM cris/ipcentos_father
RUN yum install -y curl
ENTRYPOINT [ "curl", "-s", "http://ip.cn" ]
复制代码

cris/ipcentos_father 就是上面编译完成的父镜像

当我们开始编译子镜像时,就会触发 ONBUILD 操作

三. 自定义 Tomcat9 镜像(重要)

在新建目录,并且添加以下文件

Dockerfile 内容如下

FROM         centos
MAINTAINER    cris
#把宿主机当前上下文的c.txt拷贝到容器/usr/local/路径下
COPY copy.txt /usr/local/cincontainer.txt
#把java与tomcat添加到容器中
ADD jdk-8u172-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-9.0.19.tar.gz /usr/local/
#安装vim编辑器
RUN yum -y install vim
#设置工作访问时候的WORKDIR路径，登录落脚点
ENV MYPATH /usr/local
WORKDIR $MYPATH
#配置java与tomcat环境变量
ENV JAVA_HOME /usr/local/jdk1.8.0_172
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.19
ENV CATALINA_BASE /usr/local/apache-tomcat-9.0.19
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-9.0.19/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.19/bin/logs/catalina.out
复制代码

然后开始编译

[cris@hadoop104 mytomcat]$ sudo docker build -t cris_tomcat9 .
复制代码

如果不加 -f 参数,默认从当前目录下的 Dockerfile 文件开始编译

编译成功后,直接运行

[cris@hadoop104 mytomcat]$ sudo docker run -d -p 9090:8080 --name cristomcat9 -v /home/cris/dockerFile/mytomcat/test:/usr/local/apache-tomcat-9.0.19/webapps/test -v \
> /home/cris/dockerFile/mytomcat/logs:/usr/local/apache-tomcat-9.0.19/logs  --privileged=true cris_tomcat9
复制代码

查看数据卷对应的目录

[cris@hadoop104 mytomcat]$ sudo docker inspect cristomcat9
复制代码

验证 Tomcat 是否启动

测试web 工程发布

我们在宿主机的目录上新建一个简单的 web 工程

test.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>


  
    
    Insert title here
  
  
    -----------welcome------------
    <%="i am in docker tomcat self "%>
    

    

    <% System.out.println("=============docker tomcat self");%>
  

复制代码

然后是 WEB-INF 目录下的 web.xml

xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns="http://java.sun.com/xml/ns/javaee"
  xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
  id="WebApp_ID" version="2.5">
  
  <display-name>testdisplay-name>
 
web-app>
复制代码

最后重启容器

[cris@hadoop104 test]$ sudo docker ps
CONTAINER ID        IMAGE               COMMAND                CREATED             STATUS              PORTS                    NAMES
e39ccfda5b58        cris_tomcat9        "/bin/sh -c '/usr/lo   18 minutes ago      Up 18 minutes       0.0.0.0:9090->8080/tcp   cristomcat9         
[cris@hadoop104 test]$ sudo docker restart cristomcat9
复制代码

测试

我们在宿主机修改 jsp

实时反映到 Docker 容器中的 Tomcat

在查看对应的日志

四. 总结

7. 拓展

Docker 安装常规步骤

搜索镜像
拉取镜像
查看镜像
启动镜像
停止容器
移除容器
移除镜像

7.1 安装 Tomcat

docker search tomcat
docker pull tomcat
docker image tomcat
docker run -it -p 8080:8080 tomcat
- -p 主机端口:docker容器端口
- -P 随机分配端口
- i:交互
- t:终端

7.2 安装 MySQL

docker pull mysql:5.6

验证

运行容器

[cris@hadoop104 ~]$ sudo docker run -p 12345:3306 --name mysql -v /home/cris/docker_mysql/conf:/etc/mysql/conf.d -v /home/cris/docker_mysql/logs:/logs -v /home/cris/docker_mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.6
复制代码

数据卷已建立

[cris@hadoop104 ~]$ sudo docker ps 
CONTAINER ID        IMAGE               COMMAND                CREATED             STATUS              PORTS                     NAMES
029d8863fb17        mysql:5.6           "docker-entrypoint.s   7 seconds ago       Up 6 seconds        0.0.0.0:12345->3306/tcp   mysql    
复制代码

容器已经成功跑起来了

宿主机测试是否可以连接

数据备份

docker exec myql服务容器ID sh -c ' exec mysqldump --all-databases -uroot -p"123456" ' > /home/cris/docker_mysql/all-databases.sql
复制代码

7.3 安装 Redis

先拉取: docker pull redis:3.2

然后执行以下命令运行容器

[cris@hadoop104 ~]$ sudo docker run -p 6379:6379 -v /home/cris/myredis/data:/data -v /home/cris/myredis/conf/redis.conf:/usr/local/etc/redis/redis.conf  -d redis:3.2 redis-server /usr/local/etc/redis/redis.conf --appendonly yes
复制代码

如果想要修改 Redis 的配置文件,可以直接在宿主机上对应目录修改 Redis 的配置文件即可,自动映射到Docker 容器中的 Redis

测试 redis-cli 连接

测试持久化文件生成

7.4 测试本地和阿里云仓库的镜像发布和拉取

首先,我们知道了 image 的生成方式有两种,一种是根据 DockerFile 构建;一种是根据容器 commit 新的 image

示例

首先运行一个 Docker 容器

$ sudo docker run -it cris/centos:1.2
复制代码

然后提交一个新的 image

$ sudo docker commit -a cris -m "new centos image by cris with vim and ifconfig features" 3325338e5c43 cris/centos:1.3
复制代码

登录阿里云,进行测试

创建镜像仓库

然后根据指示推送本地 image 到阿里云的 repository

$ sudo docker login [email protected] registry.cn-hangzhou.aliyuncs.com
$ sudo docker tag [ImageId] registry.cn-hangzhou.aliyuncs.com/cris_cool/mycentos:[镜像版本号]
$ sudo docker push registry.cn-hangzhou.aliyuncs.com/cris_cool/mycentos:[镜像版本号]
复制代码

ps: 这里 Cris 从本机登录阿里云仓库的时候一直无法登录,显示如下错误

Error response from daemon: no successful auth challenge for https://registry.cn-hangzhou.aliyuncs.com/v2/ - errors: [token auth attempt for registry https://registry.cn-hangzhou.aliyuncs.com/v2/: https://dockerauth.cn-hangzhou.aliyuncs.com/auth?account=990435014%40qq.com&service=registry.aliyuncs.com%3Acn-hangzhou%3A26842 request failed with status: 401 Unauthorized]
复制代码

网上搜索了后发现登录密码不对,不是登录阿里云账号的密码,需要重新设置登录 repository 的密码

然后开始推送

想要拉取也很简单

[cris@hadoop104 data]$ sudo docker pull registry.cn-hangzhou.aliyuncs.com/cris_cool/mycentos:1.3
复制代码

7.5 CentOS 7 下的 Docker 安装

参考 Docker 官网即可