Docker基本概念

由于不同的机器有不同的 *** 作系统，以及不同的库和组件，在将一个应用部署到多台机器上需要进行大量的环境配置 *** 作。

Docker 主要解决环境配置问题，它是一种虚拟化技术，对进程进行隔离，被隔离的进程独立于宿主 *** 作系统和其它隔离的进程。使用 Docker 可以不修改应用程序代码，不需要开发人员学习特定环境下的技术，就能够将现有的应用程序部署在其它机器上。

虚拟机也是一种虚拟化技术，它与 Docker 最大的区别在于它是通过模拟硬件，并在硬件上安装 *** 作系统来实现。

1启动速度

启动虚拟机需要先启动虚拟机的 *** 作系统，再启动应用，这个过程非常慢；

而启动 Docker 相当于启动宿主 *** 作系统上的一个进程。

2占用资源

虚拟机是一个完整的 *** 作系统，需要占用大量的磁盘、内存和 CPU 资源，一台机器只能开启几十个的虚拟机。

而 Docker 只是一个进程，只需要将应用以及相关的组件打包，在运行时占用很少的资源，一台机器可以开启成千上万个 Docker。

除了启动速度快以及占用资源少之外，Docker 具有以下优势：

1更容易迁移

提供一致性的运行环境。已经打包好的应用可以在不同的机器上进行迁移，而不用担心环境变化导致无法运行。

2更容易维护

使用分层技术和镜像，使得应用可以更容易复用重复的部分。复用程度越高，维护工作也越容易。

3更容易扩展

可以使用基础镜像进一步扩展得到新的镜像，并且官方和开源社区提供了大量的镜像，通过扩展这些镜像可以非常容易得到我们想要的镜像。

持续集成

持续集成指的是频繁地将代码集成到主干上，这样能够更快地发现错误。

Docker 具有轻量级以及隔离性的特点，在将代码集成到一个 Docker 中不会对其它 Docker 产生影响。

提供可伸缩的云服务

根据应用的负载情况，可以很容易地增加或者减少 Docker。

搭建微服务架构

Docker 轻量级的特点使得它很适合用于部署、维护、组合微服务。

镜像是一种静态的结构，可以看成面向对象里面的类，而容器是镜像的一个实例。

镜像包含着容器运行时所需要的代码以及其它组件，它是一种分层结构，每一层都是只读的（read-only layers）。构建镜像时，会一层一层构建，前一层是后一层的基础。镜像的这种分层存储结构很适合镜像的复用以及定制。

构建容器时，通过在镜像的基础上添加一个可写层（writable layer），用来保存着容器运行过程中的修改。

一：首先来理解三个名词解释：

1、镜像(image)

Docker 镜像（Image）就是一个只读的模板。

例如：一个镜像可以包含一个完整的 *** 作系统环境，里面仅安装了 Apache 或用户需要的其它应用程序。镜像可以用来创建 Docker 容器，一个镜像可以创建很多容器。

2、仓库(repository)

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

3、容器(container)

Docker 利用容器（Container）来运行应用。容器是从镜像（Image）创建的运行实例。

二：常用的命令集合如下：

容器生命周期管理 — docker

[run|start|stop|restart|kill|rm|pause|unpause|create]

容器 *** 作运维 — docker

[ps|exec|inspect|top|attach|events|logs|wait|export|import|port]

容器rootfs命令 — docker

[commit|cp|diff]

本地镜像管理 — docker

[images|rmi|tag|build|history|save]

镜像仓库 — docker

[login|pull|push|search]

其他命令 — docker

[info|version]

详细命令说明如下：

docker run -d --name alias-Name imageName //在后台启动一个容器

docker start Name/ID //启动容器

docker stop Name/ID //停止容器

docker restart Name/ID //重启容器

docker kill -s KILL Name/ID //杀死一个运行的容器

docker rm /rm -f Name/ID //删除容器

docker pause Name/ID //停止容器

docker unpause Name/ID //恢复容器

docker create --name CONTAINER_Name imageName //只创建容器但不启动

docker ps / docker ps -a //查看运行的容器

docker exec -it CONTAINER_ID /bin/bash //进行一个运行中的容器，开启一个新的终端

docker attach CONTAINER_ID //进行一个运行中的容器，不开启一个新的终端

docker inspect CONTAINER_Name //查看容器的相关信息

docker top CONTAINER_Name //查看容器里面的进程

docker events -f "image"="imageName" --since="1467302400" //时间戳=2016年7月1日后的相关事件

docker logs CONTAINER_Name //查看容器的日志输出

docker wait CONTAINER_Name //阻塞运行直到容器停止，然后打印出它的退出代码

docker export -o testtar CONTAINER_ID //将容器进行打包保存到本地，文件类型为tar

cat testtar |docker import - image_name:tag //将上面保存的文件导入到镜像库中

docker port CONTAINER_ID //查看容器的端口映射情况

commit 从容器中创建一个新的镜像

docker commit -a "tony test" -m "my mysql" CONTAINER_ID mymysql:v1

docker images mymysql:v1

cp 在使用的过程中会进行多个主机与容器之间的数据交换

docker cp /ruiqi/content CONTAINER_ID:/ruiqi/

diff 用来检查容器里面文件结构的更改

docker diff CONTAINER_ID

docker images /docker images -a //查看本地的镜像，-a 表示是所有的镜像

docker rmi -f image_name //删除镜像

docker tag mysql:v56 mysql:v57 //给镜像做一个有别名的复本

docker build -t runoob/ubuntu:v1 //构建一个镜像

docker history image_name //查看当前这个镜像的 历史 信息

docker save -o TestFlasktar TestFlask:v3 //将当前的镜像保存到本地的一个tar 类型的文件

docker login //登录镜像仓库

docker pull //从镜像仓库中拉镜像

docker push //向镜像仓库推本地的镜像文件

docker search //检索镜像内容

三：利用dockerfile 制作一个tomcat 运行image:

[root@localhost common]# more Dockerfiletomcat

FROM daocloudio/centos:7

COPY jdk-8u144-linux-x64rpm /opt/jdk-8u144-linux-x64rpm

RUN ["rpm","-ivh","/opt/jdk-8u144-linux-x64rpm"]

COPY security /usr/java/jdk180_144/jre/security

COPY certs /etc/pki/tls/certs

COPY tomcat /opt/tomcat

RUN ["ln","-s","/opt/tomcat","/usr/local/tomcat"]

Docker 是一个开源的应用容器引擎，基于LXC（Linux Container）内核虚拟化技术实现，提供一系列更强的功能，比如镜像、 Dockerfile等；Docker理念是将应用及依赖包打包到一个可移植的容器中，可发布到任意Linux发行版Docker引擎上。使用沙箱机制运行程序， 程序之间相互隔离；

容器是在linux上本机运行，并与其他容器共享主机的内核，它运行的一个独立的进程，不占用其他任何可执行文件的内存，非常轻量、高效、快速。

虚拟机运行的是一个完成的 *** 作系统，通过虚拟机管理程序对主机资源进行虚拟访问，相比之下需要的资源更多。

参考： >

Docker 采用了 C/S 架构，包括客户端和服务端。Docker 守护进程 （ Daemon ）作为服务端接受来自客户端的请求，并处理这些请求（创建、运行、分发容器）。

客户端和服务端既可以运行在一个机器上，也可通过 socket 或者 RESTful API 来进行通信。

命名空间是 Linux 内核一个强大的特性。每个容器都有自己单独的命名空间，运行在其中的 应用都像是在独立的 *** 作系统中运行一样。命名空间保证了容器之间彼此互不影响。

不同用户的进程就是通过 pid 命名空间隔离开的，且不同命名空间中可以有相同 pid。所有的 LXC 进程在 Docker 中的父进程为Docker进程，每个 LXC 进程具有不同的命名空间。同时由 于允许嵌套，因此可以很方便的实现嵌套的 Docker 容器。

有了 pid 命名空间, 每个命名空间中的 pid 能够相互隔离，但是网络端口还是共享 host 的端 口。网络隔离是通过 net 命名空间实现的， 每个 net 命名空间有独立的 网络设备, IP 地址, 路由表, /proc/net 目录。这样每个容器的网络就能隔离开来。Docker 默认采用 veth 的方式，将 容器中的虚拟网卡同 host 上的一个 Docker 网桥 docker0 连接在一起。

容器中进程交互还是采用了 Linux 常见的进程间交互方法(interprocess communication - IPC), 包括信号量、消息队列和共享内存等。然而同 VM 不同的是，容器的进程间交互实际上还是 host 上具有相同 pid 命名空间中的进程间交互，因此需要在 IPC 资源申请时加入命名空间信息，每个 IPC 资源有一个唯一的 32 位 id。

类似 chroot，将一个进程放到一个特定的目录执行。mnt 命名空间允许不同命名空间的进程看到的文件结构不同，这样每个命名空间中的进程所看到的文件目录就被隔离开了。同 chroot 不同，每个命名空间中的容器在 /proc/mounts 的信息只包含所在命名空间的 mount point。

UTS("UNIX Time-sharing System") 命名空间允许每个容器拥有独立的 hostname 和 domain name, 使其在网络上可以被视作一个独立的节点而非主机上的一个进程。

每个容器可以有不同的用户和组 id, 也就是说可以在容器内用容器内部的用户执行程序而非主机上的用户。

控制组（cgroups）是 Linux 内核的一个特性，主要用来对共享资源进行隔离、限制、审计 等。只有能控制分配到容器的资源，才能避免当多个容器同时运行时的对系统资源的竞争。

联合文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。

联合文件系统是 Docker 镜像的基础。镜像可以通过分层来进行继承，基于基础镜像（没有父 镜像），可以制作各种具体的应用镜像。

另外，不同 Docker 容器就可以共享一些基础的文件系统层，同时再加上自己独有的改动层， 大大提高了存储的效率。

Docker 中使用的 AUFS（AnotherUnionFS）就是一种联合文件系统。 AUFS 支持为每一个 成员目录（类似 Git 的分支）设定只读（readonly）、读写（readwrite）和写出（whiteoutable）权限, 同时 AUFS 里有一个类似分层的概念, 对只读权限的分支可以逻辑上进行增量地修改(不影响只读部分的)。

Docker 目前支持的联合文件系统包括 OverlayFS, AUFS, Btrfs, VFS, ZFS 和 Device Mapper。

最初，Docker 采用了 LXC 中的容器格式。从 07 版本以后开始去除 LXC，转而使用自行开 发的 libcontainer ，从 111 开始，则进一步演进为使用 runC 和 containerd 。

Docker 的网络实现其实就是利用了 Linux 上的网络命名空间和虚拟网络设备（特别是 veth pair）。

首先，要实现网络通信，机器需要至少一个网络接口（物理接口或虚拟接口）来收发数据包；此外，如果不同子网之间要进行通信，需要路由机制。

Docker 中的网络接口默认都是虚拟的接口。虚拟接口的优势之一是转发效率较高。 Linux 通 过在内核中进行数据复制来实现虚拟接口之间的数据转发，发送接口的发送缓存中的数据包 被直接复制到接收接口的接收缓存中。对于本地系统和容器内系统看来就像是一个正常的以 太网卡，只是它不需要真正同外部网络设备通信，速度要快很多。

Docker 容器网络就利用了这项技术。它在本地主机和容器内分别创建一个虚拟接口，并让它 们彼此连通（这样的一对接口叫做 veth pair ）。

Docker 创建一个容器的时候，会执行如下 *** 作：

完成这些之后，容器就可以使用 eth0 虚拟网卡来连接其他容器和其他网络。可以在 docker run 的时候通过 --net 参数来指定容器的网络配置：

当一个容器申请使用多于整个主机可用的内存时, 内核可能会杀掉容器或者是Docker daemon(守护进程)来释放内存, 这可能会导致所有服务不可用, 为了避免这个错误, 我们应该给每个容器限制合适的内存

我们可以在Docker-Compose或者Docker Stack环境中使用以下配置来限制容器的内存使用:

接下来我们来理解上面的配置

limitsmemory

容器允许的内存最大使用量, 最小值为4M

当容器使用了大于限制的内存时, 会发生什么, 触发程序GC还是Kill

不幸的时, 官方文档好像没有对内存限制说明得很详细, 不过Google可以帮忙, 在下面的文章中能找到一点蛛丝马迹:

再经过试验证明当程序使用超过limitsmemory限制的内存时, 容器会被Kill (cgroup干的 resource_management_guide/sec-memory )

简单的, 可以使用redis容器来进行这个实验: 限制内存为10M, 再添加大量数据给redis, 然后查看容器的状态

实际上我们不想让容器直接被Kill, 而是让Redis触发清理逻辑, 直接Kill会导致服务在一段时间内不可用(虽然会重启)

怎么办

各种调研后发现官方提供的其他参数都不能解决这个问题, 包括memory-reservation, kernel-memory, oom-kill-disable

看来并不能傻瓜化的解决这个问题, 现在如果我们只想触发程序的GC, 应该怎么做

一般来说, 程序当判定到内存不足时会有自己的GC机制, 但正如这篇文章 Understanding Docker Container Memory Limit Behavior 里所说, 运行在docker容器里的程序对内存限制是不可见的, 程序还是会申请大于docker limit的内存最终引起OOM Kill

这就需要我们额外对程序进行配置, 如 redis的maxmemory配置, java的JVM配置, 不幸的是并不是所有程序都有自带的内存限制配置, 如mysql, 这种情况下建议调低程序性能 和 保证留够的程序需要的内存

如果你的服务器开启了Swap, 有可能还会遇到一个问题: 当容器将要达到内存限制时会变得特别慢并且磁盘IO很高(达到顶峰)

这是因为我们还忽略了一个参数: memory-swap, 当没有设置memory-swap时它的值会是memory-limit的两倍, 假如设置了limit-memory=300M, 没有设置memory-swap, 这意味着容器可以使用300M内存和300M Swap >

以上就是关于Docker基本概念全部的内容，包括:Docker基本概念、Docker命令全集、10. Docker 安装与配置等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！