Docker 基础概念完全指南：从零理解容器化技术

前言

在现代软件开发中，"在我机器上能跑"是最经典的甩锅名言。Docker 的出现彻底终结了这一困境------作为一种革命性的容器化技术，Docker 让应用可以 "一次打包，处处运行"，如今已成为 DevOps、微服务架构和云原生开发的基础设施。

本文面向 Docker 初学者，系统梳理 Docker 的核心概念、运行原理、安装方法和基本操作，帮助你在最短时间内建立对 Docker 的完整认知框架。文章内容基于实际学习笔记整理，力求用最通俗的语言解释最核心的知识点。

一、Docker 是什么

1.1 一句话定义

Docker 是一个开源的 应用容器化平台 ，它能够将应用程序及其所有依赖（代码、运行时、系统库、环境变量、配置文件）打包成一个标准化的、轻量级的 容器（Container），在任何安装了 Docker 的环境中都能一致、快速地运行。

1.2 Docker 解决了什么问题

在没有 Docker 的传统开发模式中，开发者经常面临以下痛点：

痛点	具体表现
环境不一致	开发环境用 Python 3.9，生产环境是 3.7，代码行为不同
部署复杂	每次上线需要手动安装一堆依赖，容易遗漏
资源浪费	传统虚拟机每个应用都带一套完整操作系统，占用大量资源
扩展困难	新增一台服务器需要重复配置所有环境

Docker 的核心价值可以浓缩为一句话：

"一次构建（Build），随处运行（Run）" ------ Build once, Run anywhere.

1.3 Docker 与传统虚拟机的对比

很多人初次接触 Docker 时，会将其与虚拟机（VM）混淆。两者有本质区别：

维度	传统虚拟机	Docker 容器
虚拟化层级	虚拟化整个操作系统（硬件级别）	虚拟化应用层（操作系统级别）
包含内容	完整的 Guest OS + 应用 + 依赖	应用 + 依赖（共享宿主机内核）
启动速度	分钟级	秒级
资源占用	大（通常 GB 级）	极小（通常 MB 级）
隔离性	强（完全隔离）	较强（进程级隔离）
运行密度	单机十几个	单机可运行成百上千个
镜像大小	几 GB 到几十 GB	几十 MB 到几百 MB

简单理解：虚拟机是"一台电脑里模拟多台电脑"，Docker 容器是"一台电脑里运行多个隔离的应用"。

两者的架构对比：

bash 复制代码

【传统虚拟机】                        【Docker 容器】

  App A    App B    App C             App A    App B    App C
  Bins/Libs Bins/Libs Bins/Libs       Bins/Libs Bins/Libs Bins/Libs
  Guest OS  Guest OS  Guest OS             Docker Engine
  ─── Hypervisor ───                      ─── Host OS ───
       Host OS                              Host OS
       Hardware                             Hardware

Docker 容器不需要独立的操作系统内核，而是共享宿主机内核，因此更加轻量和高效。

二、Docker 运行原理与架构

2.1 Docker 整体架构

Docker 采用 客户端-服务器（Client-Server） 架构，核心由三个组件构成：

bash 复制代码

用户（终端）
   │
   │ 发送指令（如 docker run）
   ▼
Docker 客户端（Docker CLI）
   │
   │ 通过 REST API 通信
   ▼
Docker 守护进程（Docker Daemon / dockerd）
   │
   ├── 管理镜像（Images）
   ├── 管理容器（Containers）
   ├── 管理网络（Networks）
   └── 管理卷（Volumes）
        │
        │ 需要镜像时
        ▼
   Docker 仓库（Registry / Docker Hub）

三个核心组件说明：

组件	角色	类比
Docker 客户端（Client）	用户与 Docker 交互的命令行工具	餐厅的服务员
Docker 守护进程（Daemon）	核心服务进程，负责构建、运行、分发容器	餐厅的后厨
Docker 仓库（Registry）	存储和分发镜像的服务	食材供应商

当你执行 docker run nginx 时，整体流程如下：

bash 复制代码

用户输入命令
   │
   ▼
Docker CLI 将指令封装为 REST API 请求
   │
   ▼
Docker Daemon 接收请求
   │
   ├── 本地是否存在 nginx 镜像？
   │      │
   │      ├── 不存在 → 从 Docker Hub 拉取（pull）
   │      └── 存在 → 直接使用
   │
   ▼
基于镜像创建容器（分配文件系统、网络、进程空间）
   │
   ▼
启动容器中的主进程
   │
   ▼
应用运行中

2.2 不同操作系统的运行机制

Docker 底层依赖 Linux 内核特性（Namespace、Cgroups、UnionFS），因此在不同操作系统上的运行方式不同：

Linux 系统： Docker Daemon 直接运行在宿主机内核上 → 原生支持，性能最优

macOS 系统： 启动一个轻量级 Linux 虚拟机（基于 Apple Virtualization / HyperKit），Docker Daemon 运行在该虚拟机中 → 对用户透明，使用体验接近 Linux

Windows 系统： 通过 WSL2（Windows Subsystem for Linux 2）提供 Linux 内核，Docker Daemon 运行在 WSL2 的 Linux 环境中 → 需要 Windows 10 2004 及以上版本

关键理解 ：无论在什么系统上安装 Docker，本质都是在配置一个 Linux 运行环境 + Docker 引擎。Linux 用户天然拥有这个环境，而 macOS 和 Windows 需要通过虚拟化技术来提供。

三、Docker 安装指南

如果本地安装遇到困难，可以先使用 Cloud Studio（https://cloudstudio.net/）在线开发环境。它内置了 Docker 和多种语言运行环境，打开浏览器即可使用，免去了本地环境配置的烦恼。

3.1 Windows 安装

步骤一：系统要求检查

Windows 10 版本 2004 及更高版本（内部版本号 19041 及以上），或 Windows 11
BIOS / UEFI 中已启用虚拟化（Virtualization Technology）

查看 Windows 版本：Win + R → 输入 winver → 回车

如果不确定虚拟化是否开启，可以打开任务管理器 → 性能 → CPU → 查看"虚拟化"是否显示为"已启用"。

步骤二：启用 WSL2

WSL2 是 Docker 在 Windows 上运行的基石，必须先安装。

以 管理员身份 打开 PowerShell，执行：

bash 复制代码

# 启用 WSL 并安装默认 Linux 发行版
wsl --install

# 将默认版本设为 WSL2
wsl --set-default-version 2

此命令会自动完成以下操作：

1.启用"适用于 Linux 的 Windows 子系统"功能
2.启用"虚拟机平台"功能
3.下载并安装最新 Linux 内核
4.安装默认的 Ubuntu 发行版
5.将 WSL2 设为默认版本

执行完成后，重启计算机。

步骤三：安装 Docker Desktop

1.访问 Docker 官网：https://www.docker.com/products/docker-desktop
2.下载 Docker Desktop for Windows
3.双击安装程序，按向导完成安装（建议保持默认选项）
4.安装完成后，系统会提示注销或重启

步骤四：验证安装

重启后，打开 PowerShell 或 CMD：

bash 复制代码

# 查看 Docker 版本
docker --version
# 输出示例：Docker version 24.0.7, build afdd53b

# 查看 Docker Compose 版本
docker compose version
# 输出示例：Docker Compose version v2.23.3

# 运行测试容器
docker run hello-world

看到 Hello from Docker! 即表示安装成功。

3.2 macOS 安装

步骤一：确认芯片架构

Apple Silicon（M1 / M2 / M3 / M4 系列）：下载 Apple Chip 版本
Intel 芯片：下载 Intel Chip 版本

查看方法：点击左上角苹果图标 → 关于本机 → 查看"芯片"一栏

步骤二：安装 Docker Desktop

1.访问 Docker 官网：https://www.docker.com/products/docker-desktop
2.选择对应的 macOS 版本下载
3.双击下载的 .dmg 文件
4.将 Docker 图标拖拽到 Applications 文件夹

步骤三：首次启动

1.打开 Applications 中的 Docker Desktop
2.首次运行需要授权：输入系统密码
3.等待 Docker 图标出现在菜单栏右上角
4.状态栏显示 "Docker Desktop is running" 即启动成功

步骤四：验证安装

bash 复制代码

docker --version
docker compose version
docker run hello-world

3.3 Linux 安装（以 Ubuntu 为例）

Linux 是 Docker 的原生运行环境，安装最为简洁：

bash 复制代码

# 更新包索引
sudo apt-get update

# 安装依赖
sudo apt-get install -y ca-certificates curl gnupg

# 添加 Docker 官方 GPG 密钥
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg \
  | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

# 设置仓库源
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" \
  | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 安装 Docker Engine
sudo apt-get update
sudo apt-get install -y docker-ce docker-ce-cli containerd.io \
  docker-buildx-plugin docker-compose-plugin

# 将当前用户添加到 docker 组（免 sudo 使用 docker）
sudo usermod -aG docker $USER
newgrp docker

# 验证安装
docker run hello-world

3.4 安装问题排查

如果 docker run hello-world 报错，常见原因和解决办法：

错误现象	可能原因	解决办法
`Cannot connect to the Docker daemon`	Docker 服务未启动	启动 Docker Desktop 或执行 `sudo systemctl start docker`
`permission denied`	当前用户不在 docker 组	执行 `sudo usermod -aG docker $USER` 后重新登录
WSL 相关错误	WSL2 未正确安装	以管理员执行 `wsl --install` 并重启
镜像拉取超时	网络问题	配置镜像加速器（如阿里云、腾讯云加速地址）

四、Docker 四大核心概念

Docker 的整个体系建立在四个核心概念之上。理解它们及其相互关系，是掌握 Docker 的关键。

bash 复制代码

镜像（Image）────── 模板，只读的静态文件
       │
       │ docker run
       ▼
容器（Container）──── 实例，运行中的动态进程
       │
       │ 持久化需求
       ▼
卷（Volume）───────── 外挂硬盘，数据持久化

仓库（Registry）───── 镜像的"应用商店"，拉取与推送

4.1 镜像（Image）

4.1.1 什么是镜像

镜像（Image） 是 Docker 的"安装包 + 环境快照"。

它是一个 只读的静态模板，包含了运行一个应用程序所需的一切：代码、运行时环境、系统库、环境变量和配置文件。你可以把它理解为一个"已经装好所有软件的系统备份"。

类比理解：

镜像 = 类（Class）：定义了模板和蓝图
镜像 = 光盘：内容固定，只能读取不能修改
镜像 = 安装包：包含了程序运行所需的一切

4.1.2 镜像的核心特性

（1）分层存储（Layer）

镜像不是一个单一的大文件，而是由多个 只读层（Layer） 堆叠而成。每一层对应 Dockerfile 中的一条指令。

bash 复制代码

镜像分层示意（从上到下，由新到旧）：

  Layer 5: COPY app.py           ← 应用代码（最上层，最常变动）
  Layer 4: RUN pip install -r .  ← 安装 Python 依赖
  Layer 3: ENV PYTHON_VERSION    ← 设置环境变量
  Layer 2: RUN apt-get update    ← 安装系统包
  Layer 1: Ubuntu 22.04          ← 基础操作系统层（最底层，最稳定）

分层设计带来的三大优势：

共享复用：多个镜像可以共享相同的底层。例如 Python 镜像和 Node.js 镜像可能都基于 Ubuntu，Ubuntu 层只下载一次。
高效更新：修改代码后重新构建，只需重建最上面的代码层，底层缓存直接复用，构建速度大幅提升。
节省存储：相同的层在本地磁盘上只存储一份。

（2）只读性（Read-Only）

镜像一旦构建完成，其所有层都是 不可修改的（Immutable） 。这种不可变性保证了一个重要特性：无论在开发环境、测试环境还是生产环境，同一个镜像的内容 完全一致。

（3）联合文件系统（UnionFS）

联合文件系统是实现分层存储的技术基础。它将多个不同的目录（层）透明地叠加在一起，对外呈现为一个统一的文件系统视图。Docker 中最常用的联合文件系统实现是 OverlayFS。

4.1.3 为什么需要镜像

在传统开发模式中，代码依赖于本地环境。开发者说"在我机器上能跑"，但换一台机器就可能因为 Python 版本不同、缺少某个系统库、环境变量未设置等原因导致运行失败。

Docker 镜像将应用及其 整个运行时环境 打包在一起，确保了从开发 → 测试 → 生产的全流程环境 绝对一致，彻底消除了环境差异导致的问题。

4.1.4 常用镜像操作命令

bash 复制代码

# 搜索镜像
docker search nginx

# 拉取镜像（从仓库下载到本地）
docker pull nginx:latest

# 查看本地所有镜像
docker images
# 或
docker image ls

# 查看镜像的分层构建历史
docker history nginx:latest

# 删除镜像
docker rmi nginx:latest

# 给镜像打标签（常用于推送前重命名）
docker tag nginx:latest my-nginx:v1

# 导出镜像为 tar 文件（用于离线传输）
docker save -o nginx.tar nginx:latest

# 从 tar 文件导入镜像
docker load -i nginx.tar

4.2 容器（Container）

4.2.1 什么是容器

容器（Container） 是镜像的 运行时实例。

如果镜像是"静态的安装包"，那么容器就是将这个安装包"运行起来"后的动态进程。容器是 Docker 技术的最终交付物，也是应用真正执行的地方。

类比理解：

容器 = 对象（Object）：由类（镜像）实例化而来
容器 = 正在运行的程序：有生命周期，可以启动、暂停、停止、删除
容器 = 从光盘安装后正在运行的软件

4.2.2 镜像与容器的对比

维度	镜像（Image）	容器（Container）
状态	静态（只读）	动态（可读写）
本质	模板 / 蓝图	运行实例
存储	分层存储，不可变	在镜像层之上增加一个可写层
生命周期	长期存在，除非手动删除	有完整生命周期：创建→运行→暂停→停止→删除
关系	一个镜像可以创建多个容器	每个容器基于一个镜像创建
编程类比	Class（类）	Object（对象）

一个镜像可以同时运行出多个容器 ，就像一个类可以 new 出多个对象。每个容器之间相互隔离，各自拥有独立的文件系统、网络和进程空间。

4.2.3 容器的核心特点

（1）秒级启停

容器本质上是一个（或一组）进程，启动和停止就像开关服务一样快，通常在毫秒到秒级别完成，无需像虚拟机那样等待整个操作系统启动。

（2）环境隔离

每个容器都拥有独立的：

文件系统（通过可写层实现）
网络空间（独立的 IP 和端口）
进程空间（容器内的进程对宿主机默认不可见）
用户空间（独立的用户和权限体系）

这种隔离基于 Linux 内核的 Namespace （命名空间）技术实现。资源限制则通过 Cgroups（控制组）实现，可以限定容器使用的 CPU、内存等资源上限。

但容器 共享宿主机的操作系统内核，这是它比虚拟机更轻量的根本原因。

（3）极致轻量

容器不包含操作系统内核，只打包应用层代码和依赖。因此：

镜像体积小（几十 MB 到几百 MB，而非虚拟机的几 GB）
内存占用低
CPU 性能接近原生

4.2.4 容器的生命周期

bash 复制代码

Created（已创建）
   │
   │ docker start
   ▼
Running（运行中）
   │
   ├── docker pause ──▶ Paused（已暂停）
   │                        │
   │                        │ docker unpause
   │                        ▼
   │                    Running（运行中）
   │
   │ docker stop
   ▼
Exited（已停止）
   │
   ├── docker start ──▶ Running（可重新启动）
   │
   │ docker rm
   ▼
Removed（已删除，不可恢复）

4.2.5 常用容器操作命令

bash 复制代码

# ==================== 创建与启动 ====================

# 创建并启动容器（最常用）
docker run -d --name my-nginx -p 8080:80 nginx:latest
# -d            后台运行（detach 模式）
# --name        指定容器名称
# -p 8080:80    端口映射（宿主机端口:容器端口）

# 交互模式启动容器（用于调试）
docker run -it ubuntu:22.04 /bin/bash
# -i    保持标准输入打开（interactive）
# -t    分配伪终端（tty）

# ==================== 查看与管理 ====================

# 查看运行中的容器
docker ps

# 查看所有容器（包括已停止的）
docker ps -a

# 停止容器
docker stop my-nginx

# 启动已停止的容器
docker start my-nginx

# 重启容器
docker restart my-nginx

# ==================== 进入与调试 ====================

# 进入正在运行的容器
docker exec -it my-nginx /bin/bash

# 在容器内执行单条命令（不进入交互模式）
docker exec my-nginx cat /etc/nginx/nginx.conf

# 查看容器日志
docker logs my-nginx
docker logs -f my-nginx        # 实时跟踪（follow）
docker logs --tail 100 my-nginx  # 只看最后 100 行

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

# 查看容器资源占用（CPU、内存等）
docker stats

# ==================== 删除 ====================

# 删除已停止的容器
docker rm my-nginx

# 强制删除运行中的容器
docker rm -f my-nginx

# 批量删除所有已停止的容器
docker container prune

4.3 仓库（Registry）

4.3.1 什么是仓库

Docker 仓库（Registry） 是存储和分发 Docker 镜像的集中服务平台。它解决了"镜像从哪来"和"镜像放哪去"的问题。

类比理解：Docker Hub 就像是手机的"应用商店"，你可以在上面搜索、下载（pull）和上传（push）镜像。

4.3.2 仓库类型

类型	说明	典型代表
公共仓库	任何人可以访问的公共镜像平台	Docker Hub、GitHub Container Registry (ghcr.io)
私有仓库	企业或个人自行搭建的镜像仓库	Harbor、Nexus、阿里云容器镜像服务、腾讯云容器镜像服务

4.3.3 Docker Hub 详解

Docker Hub（https://hub.docker.com）是 Docker 官方提供的公共仓库，也是默认的镜像来源。它包含以下内容：

官方镜像（Official Images） ：由 Docker 官方或上游软件作者维护，经过安全审查，是最值得信赖的镜像来源。如 nginx、mysql、python、redis、node 等。
用户镜像 ：由社区用户上传，使用 用户名/镜像名 的格式，质量参差不齐，使用前需自行评估。
组织镜像 ：由企业或开源组织发布，如 bitnami/redis。

4.3.4 镜像命名规范

完整的镜像引用格式：

bash 复制代码

registry_host:port / namespace / repository : tag

完整示例：
docker.io / library / nginx : latest
    │          │         │       │
    │          │         │       └── 版本标签（tag），latest 表示最新版
    │          │         └── 镜像名称（repository）
    │          └── 命名空间（namespace），library 代表官方
    └── 仓库地址（registry），docker.io 是 Docker Hub

简写规则（使用 Docker Hub 作为默认仓库时）：

bash 复制代码

nginx              # 等价于 docker.io/library/nginx:latest
mysql:8.0          # 等价于 docker.io/library/mysql:8.0
myuser/myapp:v2    # 等价于 docker.io/myuser/myapp:v2

4.3.5 仓库核心操作

bash 复制代码

# 从仓库拉取镜像
docker pull nginx:latest

# 推送镜像到仓库（需先 docker login 登录）
docker login
docker tag my-app:1.0 myuser/my-app:1.0
docker push myuser/my-app:1.0

# 搜索镜像
docker search mysql

# 登出仓库
docker logout

4.3.6 仓库工作流程

bash 复制代码

【推送流程：本地 → 仓库】
开发者机器                    Docker Hub
──────────                   ──────────
构建镜像  ──── docker push ────▶  存储镜像


【拉取流程：仓库 → 本地】
Docker Hub                    服务器 / 开发者机器
──────────                    ──────────────────
提供镜像  ──── docker pull ────▶  运行容器

4.4 卷（Volume）

4.4.1 为什么需要卷

Docker 容器默认使用 临时文件系统（可写层） 来存储运行时产生的数据。这意味着：

容器内的所有数据（日志、数据库文件、用户上传等）都存储在容器的可写层中
一旦容器被删除，这些数据 随之永久丢失
容器的可写层与宿主机文件系统是隔离的，外部无法直接访问

卷（Volume） 就是专门为解决这些问题而设计的持久化存储方案，类似于容器的"外挂硬盘"。

4.4.2 卷的核心作用

数据持久化：将容器内的重要数据目录挂载到宿主机，容器删除后数据依然存在
数据共享：多个容器可以挂载同一个卷，实现数据互通
性能优化：卷直接读写宿主机文件系统，性能优于容器内的临时文件系统（尤其在 macOS 和 Windows 上差异明显）
备份便利：数据存储在宿主机的已知位置，便于备份和迁移

4.4.3 两种挂载方式

Docker 提供两种主要的数据挂载方式：

（1）Docker 管理卷（Named Volume）

由 Docker 自行创建和管理，数据存储在 Docker 的默认存储目录下（Linux 上通常为 /var/lib/docker/volumes/），用户不直接操作底层目录。

bash 复制代码

# 创建命名卷
docker volume create mysql_data

# 使用命名卷启动 MySQL 容器
docker run -d \
  --name my-mysql \
  -v mysql_data:/var/lib/mysql \
  -e MYSQL_ROOT_PASSWORD=123456 \
  mysql:8

# 查看所有卷
docker volume ls

# 查看指定卷的详细信息（包括存储路径）
docker volume inspect mysql_data

# 删除指定卷
docker volume rm mysql_data

# 清理所有未使用的卷
docker volume prune

（2）绑定挂载（Bind Mount）

将宿主机上的 指定目录 直接挂载到容器中。路径由用户自定义，适合开发调试场景。

bash 复制代码

# 将宿主机目录挂载到容器
docker run -d \
  --name my-mysql \
  -v /opt/mysql_data:/var/lib/mysql \
  -e MYSQL_ROOT_PASSWORD=123456 \
  mysql:8

# 挂载单个配置文件（常用于覆盖默认配置）
docker run -d \
  --name my-nginx \
  -v /opt/nginx.conf:/etc/nginx/nginx.conf:ro \
  -p 80:80 \
  nginx:latest
# :ro 表示只读挂载（read-only），容器只能读取不能写入
# :rw 表示读写挂载（read-write），这是默认值

两种方式对比：

维度	Docker 管理卷	绑定挂载
存储位置	Docker 管理（`/var/lib/docker/volumes/`）	用户指定的宿主机路径
创建方式	`docker volume create` 或首次使用时自动创建	直接指定路径即可
可移植性	高（由 Docker 统一管理）	低（依赖宿主机目录结构）
适用场景	生产环境、数据库持久化	开发调试、配置文件映射
直接访问	需通过 `docker volume inspect` 查看路径	直接在宿主机对应目录操作

4.4.4 存储层次关系

容器内的文件系统是分层组织的，理解这个层次有助于掌握卷的工作原理：

bash 复制代码

  容器可写层（Container Writable Layer）  ← 运行时临时数据，容器删除后丢失
       ↑
  镜像只读层（Image Read-Only Layers）    ← 镜像的各层，不可修改
       ↑
  ─── 虚拟边界 ───
       ↑
  宿主机文件系统（Host Filesystem）
       │
       ├── Docker 卷路径      /var/lib/docker/volumes/mysql_data/_data
       │                      （由 Docker 管理，持久化保存）
       │
       └── 绑定挂载路径       /opt/mysql_data
                              （用户指定，持久化保存）

当容器需要写入数据时：

写入普通目录 → 数据进入容器可写层（容器删除后丢失）
写入挂载了卷的目录 → 数据直接写入卷（持久保存，容器删除后仍在）

五、核心概念关系总览

理解四大概念之间的关系，是掌握 Docker 的关键。下面用一条完整的链路将所有概念串联起来：

bash 复制代码

开发者编写 Dockerfile
       │
       │ docker build
       ▼
   镜像（Image）───── 只读模板，分层存储
       │
       │ 存储于
       ▼
   仓库（Registry）─── Docker Hub / 私有仓库
       │
       │ docker pull（拉取到本地）
       ▼
   镜像（本地副本）
       │
       │ docker run（创建并启动）
       ▼
   容器（Container）── 运行实例，轻量隔离
       │
       ├── 普通数据写入 → 容器可写层（临时，容器删除后丢失）
       │
       └── 挂载卷的目录 → 卷（Volume）（持久化保存）

用一句话串联所有概念：

从仓库拉取镜像，用镜像运行容器，用卷保存容器中的重要数据。

六、常用命令速查表

镜像相关

命令	说明
`docker pull <镜像名>:<标签>`	从仓库拉取镜像
`docker images`	列出本地所有镜像
`docker rmi <镜像名>`	删除指定镜像
`docker image prune`	清理无用的悬空镜像（dangling images）
`docker tag <源> <目标>`	给镜像打标签
`docker save -o <文件名> <镜像>`	导出镜像为 tar 文件
`docker load -i <文件名>`	从 tar 文件导入镜像
`docker history <镜像名>`	查看镜像各层构建历史
`docker inspect <镜像名>`	查看镜像详细元数据

容器相关

命令	说明
`docker run -d --name <名称> <镜像>`	后台创建并启动容器
`docker run -it <镜像> /bin/bash`	交互模式启动并进入容器
`docker run -p <宿主端口>:<容器端口> <镜像>`	启动并映射端口
`docker ps`	查看运行中的容器
`docker ps -a`	查看所有容器（含已停止）
`docker start / stop / restart <容器>`	启动 / 停止 / 重启容器
`docker rm <容器>`	删除已停止的容器
`docker rm -f <容器>`	强制删除运行中的容器
`docker exec -it <容器> /bin/bash`	进入运行中的容器
`docker logs <容器>`	查看容器日志
`docker logs -f <容器>`	实时跟踪容器日志
`docker stats`	实时查看所有容器的资源占用

卷相关

命令	说明
`docker volume create <卷名>`	创建命名卷
`docker volume ls`	列出所有卷
`docker volume inspect <卷名>`	查看卷的详细信息
`docker volume rm <卷名>`	删除指定卷
`docker volume prune`	清理所有未使用的卷

系统相关

命令	说明
`docker version`	查看 Docker 版本信息
`docker info`	查看 Docker 系统级信息（镜像数、容器数、存储驱动等）
`docker system df`	查看 Docker 磁盘使用情况
`docker system prune`	清理所有未使用的资源（停止的容器、悬空镜像、未使用的网络）

七、总结

本文围绕 Docker 基础概念，系统梳理了以下核心知识：

Docker 是什么：一个开源的应用容器化平台，核心价值是"一次构建，随处运行"，彻底解决环境一致性问题。相比传统虚拟机，Docker 容器更加轻量、启停更快、资源占用更少。

运行原理：采用客户端-服务器架构，Docker CLI 通过 REST API 与 Docker Daemon 通信。底层依赖 Linux 内核的 Namespace、Cgroups 和 UnionFS 技术，macOS 和 Windows 通过虚拟化提供 Linux 环境。

镜像（Image）：只读的应用模板，采用分层存储设计，保证了环境的一致性和构建的高效性。不同镜像可以共享相同的底层，大幅节省存储空间。

容器（Container）：镜像的运行实例，秒级启停、轻量隔离、资源占用极小。容器有完整的生命周期管理，可创建、启动、暂停、停止和删除。

仓库（Registry） ：镜像的集中存储与分发平台。Docker Hub 是最常用的公共仓库，企业也可搭建 Harbor 等私有仓库。镜像通过 docker pull 和 docker push 进行拉取和推送。

卷（Volume）：容器的持久化存储方案，将数据的生命周期从容器中独立出来。支持 Docker 管理卷（适合生产环境）和绑定挂载（适合开发调试）两种方式。

bash 复制代码

知识体系总结：

Docker 容器化平台
  │
  ├── 镜像（Image）────── 只读模板，分层存储，保证环境一致
  │       │
  │       │ docker run（实例化）
  │       ▼
  ├── 容器（Container）─── 运行实例，轻量隔离，秒级启停
  │       │
  │       │ 持久化需求
  │       ▼
  ├── 卷（Volume）───────── 外挂硬盘，数据与容器生命周期分离
  │
  └── 仓库（Registry）───── 镜像的"应用商店"，负责拉取与推送

掌握这四个核心概念及其相互关系，你就建立了 Docker 的完整认知框架。后续可以在此基础上继续学习 Dockerfile 编写（自定义镜像）、Docker Compose 编排（多容器管理）、Docker 网络配置（容器间通信）等进阶内容。