当前位置：首页 > news >正文

玩转Docker（一）：基本概念

news 来源：原创 2025/5/3 6:29:31

容器技术是继大数据和云计算之后又一炙手可热的技术，而且未来相当一段时间内都会非常流行。

本文将对其基本概念和基本使用做出介绍。包括容器生态系统、容器的原理、怎样运行第一个容器、容器技术的概念与实践、Docker镜像等等

一. 鸟瞰容器生态系统

1. 容器生态系统包含哪些不同层次的技术？

2. 先了解下Docker

3. 容器、镜像、镜像仓库

4. Docker容器与虚拟机技术的区别和联系

二. 运行第一个容器

三. 容器技术

1. What - 什么是容器？

2. Why - 为什么需要容器？

3. How - 容器是如何工作的

Docker架构

Docker服务器：Docker Daemon

Docker客户端：Docker CLI

Docker镜像：Image

Docker容器：Container

Registry：存放Docker镜像的仓库

4. 小结

四. Docker镜像

1. 镜像的内部结构

hello-world -- 最小的镜像

base镜像

支持运行多种LinuxOS

2. 镜像的分层结构

3. 构建镜像

docker commit

Dockerfile

RUN vs CMD vs ENTRYPOINT

一. 鸟瞰容器生态系统

1. 容器生态系统包含哪些不同层次的技术？

容器生态系统是基于Docker等各种容器的生态系统，包含的技术层次

容器生态系统包含核心技术、平台技术和支持技术。

简而言之：

核心技术：能够让 Container 在 host 上运行的那些技术。解决的是容器自身怎样运行。
平台技术：关注一组容器如何组织运行，管理这组容器的生命周期。
容器支持技术：支持基于容器的基础设施。例如，容器网络、服务发现、监控、数据管理、日志管理、安全性等等

2. 先了解下Docker

Docker是一种开源的容器化平台，旨在简化应用程序的开发、部署和运行过程。提供了一种轻量级、可移植和自包含的容器化环境，使开发人员能够在不同计算机上以一致的方式构建、打包和分发应用程序

3. 容器、镜像、镜像仓库

容器（Container）：容器是Docker中运行应用程序的运行时实例。它是一个轻量级、可执行的软件包，包含了运行某个应用程序所需的所有内容，包括代码、运行时、系统工具、系统库和设置等。容器基于镜像创建，是镜像的运行实例。容器可以处于以下几种状态：
- 运行中：容器正在运行应用程序
- 已停止：容器已经停止运行，但仍然存在于系统中，可以随时重新启动。
- 已删除：容器被删除后，其所有数据和状态都会被清除。
镜像（Image）：镜像是容器的模板，是只读的。它包含了容器运行所需的文件系统和应用程序的初始状态。镜像是由一系列的分层文件系统组成的，每一层都包含了特定的修改或更新。
镜像仓库（Image Registry）：镜像仓库是用于存储和分发 Docker 镜像的地方。最常用的公共镜像仓库是 Docker Hub，上面有大量的官方和社区共享的镜像。此外，还可以搭建私有的镜像仓库，用于存放自己的镜像。
Dockerfile：Dockerfile 是一种文本文件，用于定义 Docker 镜像的构建过程。它包含了一系列的指令，用于指定基础镜像、安装软件、拷贝文件、配置环境等。通过 Dockerfile，可以自动化地构建镜像，确保镜像的一致性和可重复性。

4. Docker容器与虚拟机技术的区别和联系

Docker容器和虚拟机都是用于隔离和运行应用程序的技术，但它们在实现方式、性能、资源占用、启动速度等方面存在显著差异。以下是它们的主要区别：

Docker容器：容器是一种轻量级的隔离运行环境，基于宿主机的操作系统内核，共享内核但拥有独立的文件系统、网络接口和进程空间。容器启动快（通常几秒内完成），资源占用低，性能接近物理机，适合快速部署和运行应用程序，尤其适用于微服务架构和开发测试环境。
虚拟机：虚拟机通过虚拟化技术创建一个完整的虚拟计算机环境，运行独立的操作系统和应用程序。它提供强隔离性，适合运行多个不同操作系统或需要高度安全隔离的场景。虚拟机启动慢（通常几分钟），资源占用高，性能损耗较大，但可移植性强，适合长期运行且对隔离性要求高的应用。

5. 运行第一个容器

首先，请安装Docker并配置Docker的apt源。

配置Docker的APT源主要是为了确保能够从官方或可信的源中安装和更新Docker软件包，同时也能解决一些常见的问题，比如版本兼容性、软件更新以及网络访问速度等。
由于Docker Hub的服务在国外，下载镜像比较慢，最好配置成为免费的国内镜像服务。

环境就绪，马上运行第一个容器，执行命令：

docker run -d -p 80:80 httpd

结果如图所示：

其过程可以简单描述为：

1. 从Docker Hub下载httpd镜像

2. 启动httpd容器，并将容器的80端口映射到host的80端口

3. 下面可以通过浏览器验证容器是否正常工作。在浏览器中输入：http://[your ubuntu host ip]/

结果如图所示：

二. 容器技术

容器技术，需要搞清楚 What、why 和 How三个方面：什么是容器、为什么使用容器、容器是如何工作的。其中容器是怎样工作的，是容器核心知识的最主要部分。

1. What - 什么是容器？

容器是一种轻量级、可移植、自包含的软件打包技术，使应用程序可以在几乎任何地方以相同的方式运行。

容器与虚拟机

谈到容器，就不得不将它与虚拟机进行对比，因为两者都是为应用提供封装和隔离。

容器由两部分构成：应用程序本身、及其依赖（比如应用程序需要的库或者其他软件容器在Host操作系统的用户空间中运行，与操作系统的气压进程隔离，这一点显著区别于虚拟机）。
传统的虚拟化技术：目标是创建完整的虚拟机。为了运行应用，除了部署应用本及其依赖，还得安装整个操作系统。

由于所有容器共享一个host os，这使得容器在体积上要比虚拟机小很多。另外，启动容器不需要启动整个操作系统，所以容器部署和启动更快、开销更小也更容易迁移。

2. Why - 为什么需要容器？

为什么需要容器，容器到底解决了什么问题？简要的答案是，容器使软件具备了超强的移植能力。

就像集装箱解决了货物运输过程中，不同种类的货物相互影响、干扰的难题。

任何货物，不论是钢琴和保时捷，都被放到各自的集装箱中。集装箱在整个运输过程中都是密封的，只有到达最终目的地才会被打开。集装箱被誉为运输界与世界贸易最重要的发明。（容器和集装箱的英文单词都是：Container）

Docker将集装箱思想用到软件打包上，为代码提供了一个基于容器的标准化运输系统。

Docker可以将任何应用以及依赖打包成一个轻量级、可移植、自包含的容器。容器可以运行在几乎所有的操作系统上。

3. How - 容器是如何工作的

Docker架构

Docker的核心组件包括：

Docker客户端：Client
Docker服务器：Docker daemon
Docker镜像：Image
Registry
Docker容器：Container

Docker架构如图所示

Docker采用的是Client / Server架构。客户端向服务器发送请求，服务器请求构建、运行和分发容器。客户端和服务器可以运行在同一个Host上，客户端也可以通过socket或REST API与远程服务器通信。

Docker服务器：Docker Daemon

Docker 服务器是容器管理的核心，负责实际的容器生命周期管理和资源分配。

Docker服务器是Docker的后台服务进程，通常定义为Docker守护进程。它负责管理Docker的生命周期，包括创建、运行、停止、删除容器等操作。

功能：

容器管理：接收来自客户端的指令，执行容器的创建、启动、停止、删除等操作。
镜像管理：管理Docker镜像的拉取、存储和推送
网络管理：配置容器的网络环境，包括虚拟网络、端口映射等。
存储管理：管理容器的存储卷，支持数据持久化。
资源隔离：通过 Linux 内核的命名空间（Namespaces）和控制组（Cgroups）技术，为容器提供隔离的运行环境。

运行方式：Docker服务器通常在后台运行，监听来自客户端的请求，并执行相应的操作。

Docker客户端：Docker CLI

Docker 客户端是用户与 Docker 服务器之间的桥梁，提供用户友好的交互方式，方便用户发送命令和管理容器。最常用的Docker客户端是docker命令。通过docker我们可以方便地在Host上构建和运行容器。

Docker客户端是用户与Docker服务器交互的工具，通常是一个命令行界面（CLI），用户通过它发送命令来控制Docker服务器。

功能：

命令执行：用户通过命令行输入指令，如 docker run、docker build、docker stop 等，将这些指令发送给 Docker 服务器。
交互界面：提供用户友好的交互方式，方便用户管理容器和镜像。
配置管理：允许用户配置 Docker 的运行参数，如网络设置、存储驱动等。

运行方式：Docker 客户端通常运行在用户的本地机器上，通过网络（默认是本地套接字）与 Docker 服务器通信。

Docker镜像：Image

可将Docker镜像看成只读模板，通过它可以创建Docker容器。

镜像有多种生成方法：

从无到有开始创建镜像
下载并使用别人创建好的现成的镜像
在现有镜像上创建新的镜像

可以将镜像的内容和创建步骤描述在一个文本文件中，这个文件被称为Dockerfile，通过执行docker build <docker-file> 命令可以构建出Docker镜像。

Docker容器：Container

Docker容器就是Docker镜像的运行实例。

用户可以通过CLI（Docker）或是API启动、停止、移动或删除容器。可以这么认为：对于应用软件，镜像是软件生命周期的构建和打包阶段，而容器则是启动和运行阶段。

Registry：存放Docker镜像的仓库

Registry是存放Docker镜像的仓库，Registry分为私有和公有两种。

Docker Hub（https://hub.docker.com/）是默认的Registry，由Docker公司维护，上面有数以万计的镜像，用户可以自由下载和使用。

出于对速度或安全的考虑，用户也可以创建自己的私有Registry。

docker pull 命令可以从Registry下载镜像。
docker run 命令则是先下载镜像（如果本地没有），然后再启动容器。

还记得我们运行的第一个容器吗？现在通过它来体会一下Docker各个组件是如何协作的。容器启动过程如下：

1. Docker客户端执行docker run命令

2. Docker Daemon发现本地没有httpd镜像

3. daemon从Docker Hub下载镜像

4. 下载完成，镜像httpd被保存到本地

5. Docker daemon启动容器。

docker images已经可以查看到httpd已经下载到本地

docker ps 或者 docker container ls 显示容器正在运行。

4. 小结

Docker借鉴了集装箱的概念。标准集装箱将货物运往世界各地，Docker将这个模型运用到自己的设计哲学中。唯一不同的是：集装箱运输货物，Docker运输软件。

每个容器都有一个软件镜像，相当于集装箱中的货物。容器可以被创建、启动、关闭和销毁。和集装箱一样，Docker在执行这些操作时，并不关心容器里面到底装的什么，它不管里面是Web Server，还是Data-base。用户不需要关心容器最终在哪里运行，因为在哪里都可以运行

开发人员可以在笔记本上构建镜像并上传到Registry，然后QA人员将镜像下载到物理或虚拟机做测试，最终容器会部署到生产环境。

使用Docker以及容器技术，我们可以快速的构建一个应用服务器、一个消息中间件、一个数据库、一个持续集成的环境。因为Docker Hub上有我们能想到的几乎所有的镜像。

三. Docker镜像

镜像是Docker容器的基石，容器是镜像的运行实例，有了镜像才能启动容器。

本章内容安排如下：首先通过研究几个典型的镜像，分析镜像的内部结构；然后学习如何构建自己的镜像；最后介绍怎样管理和分发镜像。

1. 镜像的内部结构

为什么我们要讨论镜像的内部结构？如果只是使用镜像，当然不需要了解，直接通过Docker命令下载和运行就可以了。

但如果我们想构建自己的镜像，或者想理解Docker为什么是轻量级的，就非常有必要学习这部分知识了。

我们从一个最小的镜像开始学习。

hello-world -- 最小的镜像

hello-world是Docker官方提供的一个镜像，通常用来检验Docker是否安装成功。我们先通过docker pull 从Docker Hub下载它，如图所示：

用 docker images 查看镜像的信息，如图所示：

hello-world竟然还不到2kb，通过docker run运行，如图所示：

其实我们更关心 hello-world 镜像包含了哪些内容。

Dockerfile是镜像的描述文件，定义了如何构建Docker镜像。Dockerfile的语法简洁且可读性强，后面我们会讨论如何编写Dockerfile。

hello-world 的 Dockerfile内容如下图所示：

只有短短三条指令。

（1）From scratch镜像是白手起家，从0开始构建

（2）COPY hello/ 将文件 “hello”复制到镜像的根目录

（3）CMD ["/hello"] 容器启动时，执行 /hello

镜像hello-world中就只有一个可执行文件 “hello”，其功能就是打印出 “Hello from Docker...”等信息。

/hello 就是文件系统的全部内容，连最基本的 /bin /usr /lib /dev 都没有

hello-world虽然是一个完整的镜像，但它并没有什么实际用途。通常来说，我们希望镜像能够提供一个基本的操作系统环境，用户可以根据需要安装和配置软件。

这样的镜像我们称作 base镜像。

base镜像

base镜像有两层含义：

不依赖于其他镜像，从scratch构建
其他镜像可以以之为基础进行扩展

所以，能称作base镜像的通常都是各种Linux发行版的Docker镜像，比如Ubuntu、Debian、CentOS等。

我们以CentOS为基础为例考察base镜像包含哪些内容。

下载镜像：

docker pull centos

查看镜像信息，如下图：

镜像大小不到200MB

等一下！

一个CentOS才200MB？

平时我们安装一个CentOS至少都有几个GB，怎么可能才200MB！

相信这是几乎所有 Docker 初学者都会有的疑问，包括我自己。下面我们来解释这个问题。

Linux操作系统由内核空间和用户空间组成，如下图：

1. rootfs

内核空间是kernel，Linux刚启动时会加载bootfs文件系统，之后bootfs会被卸载掉。

用户空间的文件系统是rootfs，包含我们熟悉的 /dev /proc /bin等目录

对于 base镜像来说，底层直接用 Host 的 kernel，自己只需要提供rootfs就行了。

而对于一个精简的OS，rootfs可以很小，只需要包括最基本的命令、工具和程序库就可以了。相比其他的Linux发行版，CentOS的rootfs已经算臃肿的了，alpine还不到10MB
我们平时还会安装的CentOS除了rootfs之外，还会选装很多软件、服务、图形桌面等等，需要好几个GB就不足为奇了。

2. base镜像提供的是最小安装的Linux发行版

CentOS镜像的Dockerfile的内容如下图所示：

第二行ADD指令添加到镜像的 tar 包就是 CentOS 7 的rootfs，在制作镜像时，这个tar包会自动解压到 / 目录下，生成 /dev、/proc、/bin等目录。

支持运行多种LinuxOS

不同Linux发行版的区别主要就是rootfs，所以Docker可以同时支持多种Linux镜像，模拟出多种操作系统环境。

上图Debian和BusyBox（一种嵌入式Linux）上层提供各自的rootfs，底层共用Docker Host的kernel

2. 镜像的分层结构

Docker支持通过扩展现有镜像，创建新的镜像。

实际上，Docker Hub中99%的镜像都是通过在base镜像中安装和配置需要的软件构建出来的。比如我们构建一个新的镜像，Dockerfile 如下图所示：

（1）新镜像不再是从scratch开始，而是直接在Debian base镜像上创建

（2）安装 emacs 编辑器

（3）安装 Apache2

（4）容器启动时运行 bash

构建过程中如下图：

可以看到，新镜像是从base镜像一层一层叠加生成的。每安装一个软件，就在现有镜像的基础上增加一层。

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

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

3. 构建镜像

对于Docker用户来说，最好的情况是不需要自己创建镜像。几乎所有常用的数据库、中间件、应用软件等都有现成Docker官方镜像或其他人和组织创建的镜像，我们只需要稍作配置就可以直接使用。

使用现成镜像的好处除了省去自己做镜像的工作量外，更重要的是可以利用前人的经验。特别是使用官方的镜像，因为Docker工程师更知道如何更好地在容器中运行软件。

当然，某些情况下我们也不得不自己构建镜像，比如：

（1）找不到现成的镜像，比如自己开发的应用程序。

（2）需要在镜像中加入特定的功能，比如官方镜像几乎都不提供ssh

所以本节我们将介绍构建镜像的方法。同时分析构建的过程也能够加深我们对前面镜像分层结构的理解。

Docker提供了两种构建镜像的方法：docker commit命令与Dockerfile构建文件。

docker commit

docker commit 命令是创建新镜像最直观的方法，其过程包含三个步骤：

运行容器
修改容器
将容器保存为新的镜像

举个例子：在Ubuntu base镜像中安装vi并保存为新镜像。

（1）运行容器

如图所示：

-it的作用是以交互模式进入容器，并打开终端。

（2）安装vi

确认vi没有安装，如下图所示：

安装vi，如下图所示：

（3）保存为新镜像

在新窗口中查看当前运行的容器，如图所示：

silly_goldberg是Docker为我们容器随机分配的名字。

执行 docker commit 命令将容器保存为镜像，如图所示：

新镜像命名为ubuntu-with-vi

查看新镜像的属性，如图所示：

从size上看到镜像因为安装了软件而变大了。

从新镜像启动容器，验证 vi 已经可以使用，如图所示：

以上演示了如何用 docker commit创建新镜像。然而，Docker并不建议用户通过这种方式构建镜像。原因如下：

（1）这是一种手动创建镜像的方式，容易出错，效率低且可重复性若。比如要在 debian base镜像中也加入vi，还得重复前面所有的步骤。

（2）更重要的：使用者并不知道镜像是如何创建出来的，里面是否有恶意程序。也就是说无法对镜像进行审计，存在安全隐患。

既然 docker commit不是推荐的方法，我们为什么还要花时间学习呢？原因是，即便是用Dockerfile（推荐方法）构建镜像，底层也是docker commit一层一层构建新镜像的。学习docker commit 能够帮助我们更加深入地理解构建过程和镜像的分层结构。

Dockerfile

Dockerfile是一个文本文件，记录了镜像够简单的所有步骤。

1. 第一个Dockerfile

用 Dockerfile 创建上节的 ubuntu-with-vi，其内容如图所示：

下面我们运行 docker build 命令构建镜像并详细分析每个细节。

root@ubuntu:～# pwd ①/rootroot@ubuntu:～# ls ②Dockerfileroot@ubuntu:～# docker build -t ubuntu-with-vi-dockerfile . ③Sending build context to Docker daemon 32.26 kB ④Step 1 : FROM ubuntu ⑤---> f753707788c5Step 2 : RUN apt-get update && apt-get install -y vim ⑥---> Running in 9f4d4166f7e3 ⑦......Setting up vim (2:7.4.1689-3ubuntu1.1) ...---> 35ca89798937 ⑧Removing intermediate container 9f4d4166f7e3 ⑨Successfully built 35ca89798937 ⑩root@ubuntu:～#

① 当前目录为 /root。

② Dockerfile准备就绪。

③ 运行docker build命令，-t将新镜像命名为ubuntu-with-vi-dockerfile，命令末尾的．指明build context为当前目录。Docker默认会从build context中查找Dockerfile文件，我们也可以通过-f参数指定Dockerfile的位置。

④ 从这步开始就是镜像真正的构建过程。

首先Docker将build context中的所有文件发送给Docker daemon。build context为镜像构建提供所需要的文件或目录。 Dockerfile中的ADD、COPY等命令可以将build context中的文件添加到镜像。此例中，build context为当前目录 /root，该目录下的所有文件和子目录都会被发送给Docker daemon。所以，使用build context就得小心了，不要将多余文件放到build context，特别不要把 /、/usr作为build context，否则构建过程会相当缓慢甚至失败。

⑤ Step 1：执行FROM，将Ubuntu作为base镜像。 Ubuntu镜像ID为f753707788c5。

⑥ Step 2：执行RUN，安装vim，具体步骤为 ⑦ ⑧ ⑨。

⑦ 启动ID为9f4d4166f7e3的临时容器，在容器中通过apt-get安装vim。

⑧ 安装成功后，将容器保存为镜像，其ID为35ca89798937。这一步底层使用的是类似docker commit的命令。

⑨ 删除临时容器9f4d4166f7e3。

⑩ 镜像构建成功。

通过docker images查看镜像信息，如图3-21所示。 [插图] 图3-21 镜像ID为35ca89798937，与构建时的输出一致。在上面的构建过程中，我们要特别注意指令RUN的执行过程 ⑦ ⑧ ⑨。Docker会在启动的临时容器中执行操作，并通过commit保存为新的镜像。

2. 查看镜像的分层结构

ubuntu-with-vi-dockerfile 是通过在base镜像的顶部增加一个新的镜像层而得到的，如图所示：

这个新镜像层的内容由 RUN apt-get update && apt-get in stall -y vim 生成。这一点我们可以通过docker history命令验证，如图所示：

docker history会显示镜像的构建历史，也就是Dockerfile的执行过程。

ubuntu-with-vi-dockerfile 与 Ubuntu 镜像相比，确实只是多了顶部的一层35ca89798937，由apt-get命令创建，大小为97.07MB。docker history向我们展示了镜像的分层结构，每一层由上至下排列。

注：missing表示无法获取IM-AGE ID，通常从 Docker Hub 下载的镜像会有这个问题。

3. 镜像的缓存特征

我们接下来看Docker镜像的缓存特征。

Docker会缓存已有镜像的镜像层，构建新镜像时，如果某镜像直接存在，就直接使用，无需重新创建。

例如，如果在Dockerfile中添加一点新内容，往镜像中复制一个文件：

（1）确保 testfile 已存在

（2）由于之前已经运行过相同的 RUN 命令，这次直接使用缓存中的镜像层 35ca89798937

（3）执行 COPY 命令

其过程是启动临时容器，复制 testfile，提交新的镜像层 8d02784a78f4，删除临时容器。

在ubuntu-with-vi-dockerfile 镜像上直接添加一层就得到了新的镜像 ubuntu-with-vi-docker-file-2，如图所示：

如果我们希望在构建镜像时不使用缓存，可以在 docker build 命令中加上 no-cache 参数。

Dockerfile每一个指令就会创建一个镜像层，上层是依赖于下层的。无论什么时候，只要某一层发生变化，其上面所有层的缓存都会失效。

也就是说，如果我们改变 Dockerfile 的执行顺序，或者修改或者添加指令，都会使缓存失效。举例说明：

如果交换前面 RUN 和 COPY 的顺序，如图所示：
虽然在逻辑上这种改动对镜像的内容没有影响，但由于分层的结构特征，Docker必须重建受影响的镜像层。
从执行过程可以看到，生成了新的镜像层，缓存已经失效。

除了构建时使用缓存，Docker在下载镜像时也会使用。

4. 调试Dockerfile

总结一下通过 Dockerfile 构建镜像的过程：

（1）从base镜像运行一个容器

（2）执行一条指令，对容器做修改

（3）执行类似docker commit的操作，生成一个新的镜像

（4）Docker再基于刚刚提交的镜像运行一个新容器

（5）重复2~~4步，直到Dockerfile中的所有指令执行完毕

5. Dockerfile 常用指令

是时候系统学习Dockerfile了

FROM：指定base镜像
MAINTAINER：设置镜像作者，可以是任意字符串
COPY：
- 将文件从build context复制到镜像
- COPY支持两种形式：COPY src dest 与 COPY ["src", "dest"]
- 注意，src只能指定 build context 中的文件或目录
ADD：
- 与COPY类似，从 build context 复制文件到镜像。不同的是，如果 src 是归档文件（tar、zip、tgz、xz等），文件会被自动解压到dest
ENV：
- 设置环境变量，环境变量可以被后面的指令使用。例如：
- ENV MY_VERSION 1.3 RUN apt-get install -y mypackage=$MY_VERSION
EXPOSE：
- 指定容器中的进程会监听某一个端口，Docker可以将该端口暴露出来。
VOLUMN：
- 将文件或者目录声明为volume
WORKDIR：
- 为后面的RUN、CMD、ENTRY-POINT、ADD或COPY指令设置镜像中的当前工作目录
RUN
- 在容器中执行指定的命令
CMD
- 容器启动时运行指定的命令
- Dockerfile可以有多个CMD指令，但只有最后一个生效。CMD可以被 docker run 之后的参数替换。
ENTRYPOINT
- 设置容器启动时运行的命令。
- Dockerfile中可以有多个ENTRYPOINT指令，但只有最后一个生效。CMD 或 docker run之后的参数会被当做参数传递给 ENRTYPOINT。