一、Docker 简介：什么是 Docker，为什么要用它？

1.1 Docker 的定义

Docker 是一个开源的应用容器引擎，基于 Go 语言开发，遵循 Apache 2.0 开源协议。它能够将应用程序及其依赖项打包到一个可移植的容器中，然后发布到任何支持 Docker 的操作系统上，实现“一次打包，到处运行”的效果。与传统的虚拟机技术不同，Docker 容器不依赖于底层操作系统的虚拟化，而是共享宿主机的内核，因此具有启动速度快、资源占用少、可移植性强等优势。

1.2 Docker 的核心价值

在 Docker 出现之前，开发者常常面临“开发环境能跑，生产环境跑不起来”的困境，核心原因在于开发环境、测试环境、生产环境的配置不一致，以及依赖项版本冲突等问题。Docker 的出现，正是为了解决这些痛点，其核心价值主要体现在以下几个方面：

  • 环境一致性：将应用及其依赖（如编程语言、库、配置文件等）打包成容器，容器在任何支持 Docker 的环境中运行时，都能保持一致的运行效果，彻底解决“环境不一致”问题。
  • 资源高效利用：Docker 容器共享宿主机内核，不需要像虚拟机那样占用独立的内存、CPU 和操作系统资源，启动时间通常在秒级，资源利用率远高于虚拟机。
  • 可移植性强：容器可以在本地、服务器、云平台之间自由迁移，只要目标环境支持 Docker，就能直接运行，无需修改任何配置。
  • 简化部署与运维：通过 Docker 可以快速部署应用，实现自动化运维，减少人工操作，降低部署失误的概率，同时便于应用的扩容与缩容。
  • 隔离性良好：每个容器都是独立的运行环境，容器之间相互隔离，不会相互影响，避免了应用之间的冲突，提高了系统的稳定性和安全性。

1.3 Docker 与虚拟机的区别

很多新手会将 Docker 与虚拟机混淆，但两者在底层实现、资源占用、启动速度等方面有本质区别，具体对比如下表所示：

对比维度

Docker 容器

虚拟机（VM）

底层实现

共享宿主机内核，基于容器化技术

虚拟化底层硬件，运行独立操作系统

资源占用

占用资源少，轻量级

占用资源多，重量级

启动速度

秒级启动

分钟级启动

隔离性

进程级隔离，隔离性较弱

系统级隔离，隔离性强

可移植性

强，可跨平台迁移

弱，依赖虚拟化软件和底层系统

简单来说，虚拟机是“模拟一个完整的操作系统”，而 Docker 容器是“模拟一个应用的运行环境”，两者的定位不同，适用场景也不同。在实际开发中，通常会结合两者的优势，比如用虚拟机提供底层环境，用 Docker 容器部署应用。

二、Docker 核心概念：吃透这5个概念，入门就成功了一半

Docker 有5个核心概念，分别是：镜像（Image）、容器（Container）、仓库（Repository）、Dockerfile、Docker Compose。这5个概念是理解 Docker 工作流程的关键，下面逐一详细讲解，并搭配代码示例，帮助大家快速掌握。

2.1 镜像（Image）：容器的“模板”

2.1.1 镜像的定义

镜像（Image）是 Docker 中最基础的概念，它是一个只读的模板，包含了运行应用程序所需的所有文件、依赖项、配置信息和操作系统内核。可以把镜像理解为“容器的模板”，一个镜像可以创建多个容器，就像一个类可以实例化多个对象一样。

例如，一个 Nginx 镜像，就包含了 Nginx 服务器的安装文件、配置文件、依赖的库文件等，通过这个镜像，我们可以快速创建多个 Nginx 容器，每个容器都是独立运行的 Nginx 服务。

2.1.2 镜像的核心特性
  • 只读性：镜像一旦创建，就无法修改，只能通过创建新的镜像来实现更新。
  • 分层存储：Docker 镜像采用分层存储技术，每一层都是一个独立的文件系统，层与层之间相互依赖。这种分层结构可以实现镜像的复用，减少存储空间的占用。例如，多个镜像可能共享同一个基础层（如 Ubuntu 系统层），只需要存储一次基础层，就能被多个镜像复用。
  • 可继承性：可以基于一个已有的镜像，通过添加新的层，创建一个新的镜像。例如，基于 Ubuntu 镜像，安装 Python 环境，就能创建一个 Python 镜像。
2.1.3 镜像相关常用命令（代码示例）

下面是镜像操作的常用命令，所有命令均在 Linux 终端（或 Windows Docker Desktop 终端）中执行，大家可以直接复制执行，感受镜像的操作流程。

复制代码

# 1. 拉取镜像（从 Docker Hub 拉取官方镜像）
# 拉取最新版 Nginx 镜像
docker pull nginx:latest
# 拉取指定版本的 Nginx 镜像（如 1.24.0）
docker pull nginx:1.24.0

# 2. 查看本地所有镜像
docker images
# 输出示例：
# REPOSITORY   TAG       IMAGE ID       CREATED        SIZE
# nginx        latest    605c77e624dd   2 weeks ago    142MB
# nginx        1.24.0    08393e824c32   2 months ago   141MB

# 3. 查看镜像详细信息
docker inspect nginx:latest

# 4. 给镜像打标签（便于区分镜像版本）
docker tag nginx:latest my-nginx:v1.0

# 5. 删除本地镜像
# 删除指定标签的镜像
docker rmi nginx:1.24.0
# 强制删除镜像（如果镜像已被容器使用）
docker rmi -f nginx:latest

# 6. 保存镜像为本地文件（便于迁移）
docker save -o nginx.tar nginx:latest

# 7. 加载本地镜像文件
docker load -i nginx.tar

复制代码

说明：Docker Hub 是 Docker 官方的镜像仓库，包含了大量官方和第三方的镜像，我们可以通过 docker pull 命令直接拉取镜像，无需自己手动构建。

2.2 容器（Container）：镜像的“实例”

2.2.1 容器的定义

容器（Container）是基于镜像创建的可运行实例，是 Docker 中用于运行应用程序的载体。如果说镜像是“模板”，那么容器就是“模板实例化后的对象”，它可以被启动、停止、重启、删除，并且容器之间相互隔离，拥有独立的运行环境。

容器与镜像的关系，就像进程与程序的关系：程序是静态的代码和资源，进程是程序的运行实例；镜像也是静态的模板，容器是镜像的运行实例。

2.2.2 容器的核心特性
  • 可运行性：容器是基于镜像创建的，包含了应用程序的运行环境，能够直接启动并运行应用。
  • 可写性：容器在运行过程中，会在镜像的只读层之上添加一个可写层，所有对容器的修改（如创建文件、修改配置）都会保存在这个可写层中，不会影响原始镜像。
  • 隔离性：每个容器都有自己独立的网络、进程、文件系统，与其他容器和宿主机隔离，避免相互干扰。
  • 轻量级：容器共享宿主机内核，不需要占用独立的操作系统资源，启动速度快，资源占用少。
2.2.3 容器相关常用命令（代码示例）

容器的操作是 Docker 日常使用中最频繁的，下面的命令涵盖了容器的创建、启动、停止、删除、进入等常用操作，建议大家实际操作一遍，加深理解。

复制代码

# 1. 基于镜像创建并启动容器
# 格式：docker run [选项] 镜像名:标签 [容器内执行的命令]
# 示例1：启动 Nginx 容器，后台运行，映射宿主机80端口到容器80端口
docker run -d -p 80:80 --name my-nginx nginx:latest
# 选项说明：
# -d：后台运行容器（守护进程模式）
# -p 80:80：将宿主机的80端口映射到容器的80端口（宿主机端口:容器端口）
# --name my-nginx：给容器命名为 my-nginx，便于后续操作

# 示例2：启动 Ubuntu 容器，进入交互模式（可以在容器内执行命令）
docker run -it --name my-ubuntu ubuntu:latest /bin/bash
# 选项说明：
# -it：交互模式（-i 保持标准输入打开，-t 分配伪终端）
# /bin/bash：容器启动后执行的命令，进入 bash 终端

# 2. 查看正在运行的容器
docker ps
# 查看所有容器（包括已停止的）
docker ps -a

# 3. 启动、停止、重启容器
# 启动已停止的容器
docker start my-nginx
# 停止正在运行的容器
docker stop my-nginx
# 重启容器
docker restart my-nginx

# 4. 进入正在运行的容器（交互模式）
# 方法1：exec 命令（推荐，不会影响容器的运行状态）
docker exec -it my-nginx /bin/bash
# 方法2：attach 命令（进入容器后，退出会导致容器停止）
docker attach my-nginx

# 5. 查看容器日志（用于排查问题）
docker logs my-nginx
# 实时查看日志（类似 tail -f）
docker logs -f my-nginx

# 6. 查看容器详细信息
docker inspect my-nginx

# 7. 删除容器（需先停止容器，或强制删除）
# 删除已停止的容器
docker rm my-nginx
# 强制删除正在运行的容器
docker rm -f my-nginx

# 8. 容器与宿主机之间复制文件
# 宿主机文件复制到容器内：docker cp 宿主机路径 容器名:容器内路径
docker cp /home/test.txt my-nginx:/usr/share/nginx/html
# 容器内文件复制到宿主机：docker cp 容器名:容器内路径 宿主机路径
docker cp my-nginx:/usr/share/nginx/html/index.html /home
实操验证：执行 docker run -d -p 80:80 --name my-nginx nginx:latest 命令后，打开浏览器，访问 http://localhost，如果能看到 Nginx 的默认欢迎页面，说明容器启动成功，端口映射生效。

复制代码

2.3 仓库（Repository）：镜像的“仓库”

2.3.1 仓库的定义

仓库（Repository）是用于存储和管理 Docker 镜像的地方，类似于代码仓库（如 GitHub），我们可以将自己构建的镜像推送到仓库，也可以从仓库拉取别人上传的镜像。

仓库分为公有仓库和私有仓库：

  • 公有仓库：对外开放，所有人都可以拉取镜像，最常用的是 Docker Hub（https://hub.docker.com/），包含了大量官方镜像和第三方镜像。
  • 私有仓库：仅对特定用户或团队开放，用于存储企业内部的镜像，避免敏感镜像泄露，常用的私有仓库有 Docker Registry、Harbor 等。
2.3.2 仓库相关常用命令（代码示例）

复制代码

# 1. 登录 Docker Hub（需先注册 Docker Hub 账号）
docker login
# 输入用户名和密码，登录成功后，即可推送镜像到 Docker Hub

# 2. 推送镜像到 Docker Hub（需先给镜像打标签，标签格式：用户名/镜像名:标签）
# 示例：给本地 Nginx 镜像打标签，推送至自己的 Docker Hub 仓库
docker tag nginx:latest your-username/my-nginx:v1.0
docker push your-username/my-nginx:v1.0

# 3. 从 Docker Hub 拉取自己推送的镜像
docker pull your-username/my-nginx:v1.0

# 4. 退出 Docker Hub 登录
docker logout

# 5. 私有仓库相关操作（以 Docker Registry 为例）
# 拉取私有仓库镜像（需先登录私有仓库）
docker login private-registry-url:port
docker pull private-registry-url:port/my-nginx:v1.0
# 推送镜像到私有仓库
docker tag nginx:latest private-registry-url:port/my-nginx:v1.0
docker push private-registry-url:port/my-nginx:v1.0

复制代码

2.4 Dockerfile：构建镜像的“脚本”

2.4.1 Dockerfile 的定义

Dockerfile 是一个文本文件，包含了一系列的指令（Instruction），用于描述如何构建一个 Docker 镜像。通过 Dockerfile，我们可以自定义镜像的内容，比如安装特定的软件、配置环境变量、复制文件等，实现镜像的自动化构建。

Dockerfile 的核心作用是“标准化镜像构建流程”，只要有 Dockerfile，任何人都可以按照相同的步骤构建出相同的镜像，避免了手动构建镜像的繁琐和误差。

2.4.2 Dockerfile 常用指令

Dockerfile 中的指令有固定的格式，通常以大写字母开头，后面跟随具体的参数，常用指令如下：

  • FROM：指定基础镜像，是 Dockerfile 的第一个指令，用于指定构建镜像的基础模板。例如 FROM ubuntu:latest，表示基于最新版的 Ubuntu 镜像构建新镜像。
  • WORKDIR：指定容器运行时的工作目录，后续的指令（如 RUN、COPY）都会在这个目录下执行。例如 WORKDIR /app，表示工作目录为 /app。
  • COPY：将宿主机的文件或目录复制到镜像中。例如 COPY ./app.py /app，表示将宿主机当前目录下的 app.py 文件复制到镜像的 /app 目录下。
  • ADD：与 COPY 类似，也用于复制文件，但支持解压压缩文件和从 URL 下载文件。例如 ADD ./app.tar.gz /app，表示将宿主机的 app.tar.gz 压缩文件复制到镜像的 /app 目录，并自动解压。
  • RUN：在构建镜像时执行命令，用于安装软件、配置环境等。例如 RUN apt update && apt install -y python3，表示更新软件源并安装 Python3。
  • ENV：设置环境变量，在镜像构建和容器运行时都生效。例如 ENV PYTHONPATH=/app，表示设置 Python 的环境变量。
  • EXPOSE：声明容器运行时监听的端口，只是一个声明，不会自动映射端口，需要在 docker run 时使用 -p 选项进行端口映射。例如 EXPOSE 8080，表示容器监听 8080 端口。
  • CMD：指定容器启动时执行的命令，一个 Dockerfile 中只能有一个 CMD 指令，若有多个，只有最后一个生效。例如 CMD ["python3", "app.py"]，表示容器启动时执行 python3 app.py 命令。
  • ENTRYPOINT：与 CMD 类似，也用于指定容器启动时执行的命令，但 ENTRYPOINT 的命令不会被 docker run 后面的命令覆盖，而 CMD 会被覆盖。例如 ENTRYPOINT ["python3"]，如果执行docker run -it my-image app.py，则容器启动时执行 python3 app.py。
2.4.3 Dockerfile 构建镜像示例（代码示例）

下面我们通过一个实际案例，使用 Dockerfile 构建一个 Python 应用镜像，步骤如下：

  1. 创建一个工作目录，新建 Dockerfile 文件和 Python 应用文件（app.py）。
  2. 编写 Dockerfile 指令，定义镜像的构建流程。
  3. 使用 docker build 命令构建镜像。
  4. 基于构建好的镜像启动容器，验证应用是否能正常运行。

复制代码

# 1. 创建工作目录并进入
mkdir python-app && cd python-app

# 2. 新建 app.py 文件（简单的 Python Web 应用，使用 Flask 框架）
cat > app.py << EOF
from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello():
    return "Hello Docker! This is a Python App."

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8080)
EOF

# 3. 新建 Dockerfile 文件，编写构建指令
cat > Dockerfile << EOF
# 指定基础镜像（Python 3.10 官方镜像）
FROM python:3.10-slim

# 设置工作目录
WORKDIR /app

# 复制宿主机的 app.py 文件到镜像的 /app 目录
COPY app.py /app

# 安装 Flask 依赖
RUN pip install flask -i https://pypi.tuna.tsinghua.edu.cn/simple

# 声明容器监听的端口
EXPOSE 8080

# 指定容器启动时执行的命令
CMD ["python3", "app.py"]
EOF

# 4. 构建镜像（-t 选项指定镜像标签，格式：镜像名:标签）
docker build -t my-python-app:v1.0 .
# 说明：最后的 "." 表示 Dockerfile 所在的当前目录

# 5. 基于构建好的镜像启动容器，映射 8080 端口
docker run -d -p 8080:8080 --name my-python-app my-python-app:v1.0

# 6. 验证应用是否正常运行（访问 http://localhost:8080，查看是否返回指定内容）
curl http://localhost:8080
验证结果：执行 curl http://localhost:8080 后，如果输出 Hello Docker! This is a Python App.，说明镜像构建成功，容器运行正常。

复制代码

2.5 Docker Compose：多容器管理工具

2.5.1 Docker Compose 的定义

在实际开发中，一个应用往往需要多个容器协同工作，比如一个 Web 应用需要 Web 容器、数据库容器、缓存容器等。如果手动一个个启动、配置这些容器，会非常繁琐，且容易出错。Docker Compose 就是为了解决多容器管理问题而出现的工具。

Docker Compose 是 Docker 官方提供的多容器编排工具，基于 YAML 文件定义多个容器的配置（如镜像、端口映射、环境变量、依赖关系等），通过一条命令就能启动、停止、重启所有相关容器，实现多容器的自动化管理。

2.5.2 Docker Compose 常用命令与示例（代码示例）

首先需要安装 Docker Compose（Docker Desktop 已内置 Docker Compose，Linux 系统需手动安装），然后通过编写 docker-compose.yml 文件定义多容器配置，最后使用 docker compose 命令进行操作。

下面以“Web 应用 + MySQL 数据库”为例，演示 Docker Compose 的使用：

复制代码

# 1. 创建工作目录并进入
mkdir web-mysql && cd web-mysql

# 2. 新建 docker-compose.yml 文件（核心配置文件）
cat > docker-compose.yml << EOF
version: '3.8'  # 指定 Docker Compose 的版本

# 定义所有服务（容器）
services:
  # 定义 Web 服务（基于之前构建的 my-python-app 镜像）
  web:
    image: my-python-app:v1.0  # 指定镜像
    ports:
      - "8080:8080"  # 端口映射
    depends_on:
      - mysql  # 依赖 mysql 服务，mysql 启动后再启动 web
    environment:  # 设置环境变量（用于连接 MySQL）
      - MYSQL_HOST=mysql
      - MYSQL_USER=root
      - MYSQL_PASSWORD=123456
# docker # 架构 # 容器
Logo
openEuler 社区

openEuler 是由开放原子开源基金会孵化的全场景开源操作系统项目，面向数字基础设施四大核心场景（服务器、云计算、边缘计算、嵌入式），全面支持 ARM、x86、RISC-V、loongArch、PowerPC、SW-64 等多样性计算架构

更多推荐

一多操作系统 - 自举·一切皆组件的下一代可组合软件平台（新版）

热力学第二定律告诉我们，封闭系统总是趋向于无序（熵增，即复杂度增加）。传统操作系统就是典型的熵增系统，代码越堆越乱。WIT 接口：定义了秩序（边界）。Wasm 沙箱：定义了隔离（互不干扰）。AI 适配器：提供了进化（自动修复）。资源组件化：实现了共享（无零和）。所以，只要目录设计得足够优雅、足够抽象，整个系统的复杂度就会被死死地锁在那个小小的目录里，而不会扩散到整个代码库。这就是"组合"的魔力：用

avatar openEuler 社区
cover

Linux网络编程（十一）：守护进程、进程组与会话机制

avatar openEuler 社区

深入浅出讲解操作系统——进程同步

本文章是运用deepseek生成的操作系统讲解，其中还有本人对操作系统知识的理解概括以及怎么向ds提问，以及思考的过程，围绕专业讲解＋通俗讲解两种模式，灵活使用AI提高学习效率，本专栏会持续更新完善。

avatar openEuler 社区