📚前言
回顾，系统学习docker系列的总计划如下：
本文，是计划的第一周的内容，内容纲要如下：
第1周：Docker 核心概念
- Docker 是什么：容器技术的概念、与虚拟机的区别
- Docker 核心组件：镜像(Image)、容器(Container)、仓库(Repository)
- Docker 架构：Docker 引擎、Docker daemon、Docker CLI
- 容器化的优势：轻量、可移植、一致性、隔离性
🌍正文
一、Docker是什么？
1.1 容器技术的概念
想象一下这个场景：
你写了一个Python程序，在你的电脑上运行得很好。但是当你把它发给朋友时，朋友说"运行不了"。原因可能是：
- 你的Python是3.9版本，朋友的是3.7版本
- 你安装了某个库，朋友没有安装
- 你的操作系统是Windows，朋友用的是Mac
👍Docker就是为了解决这个"在我的机器上能运行，在其他机器上不能运行"的问题而诞生的。
容器就像是一个"标准化的快递箱"。无论你在哪里，无论你的电脑环境如何，只要把程序和它需要的所有东西都装进这个"快递箱"里，它就能在任何地方以相同的方式运行。
1.2 Docker与虚拟机的区别
这是初学者最容易混淆的概念。让我们用一个生活中的例子来理解：
虚拟机（VM）就像"独栋别墅"
┌─────────────────────────────────────┐
│ 虚拟机架构示意图 │
├─────────────────────────────────────┤
│ ┌──────────┐ ┌──────────┐ │
│ │ App A │ │ App B │ │
│ ├──────────┤ ├──────────┤ │
│ │Guest OS │ │Guest OS │ ← 每个虚拟机都需要完整的操作系统
│ ├──────────┤ ├──────────┤ │
│ │ Hypervisor (虚拟化管理器) │
│ ├─────────────────────────────────┤
│ │ Host OS (宿主操作系统) │
│ ├─────────────────────────────────┤
│ │ 物理硬件 │
│ └─────────────────────────────────┘特点：
- 每个虚拟机都有完整的操作系统（可能几GB大小）
- 启动慢（需要几分钟）
- 资源占用大
- 隔离性强
Docker容器就像"公寓楼里的独立公寓"
┌─────────────────────────────────────┐
│ Docker容器架构示意图 │
├─────────────────────────────────────┤
│ ┌──────────┐ ┌──────────┐ ┌──────┐│
│ │ App A │ │ App B │ │App C ││
│ ├──────────┤ ├──────────┤ ├──────┤│
│ │ Libs/Deps│ │ Libs/Deps│ │Libs ││ ← 只包含程序和依赖库
│ ├──────────┴─┴──────────┴─┴──────┤│
│ │ Docker Engine (容器引擎) ││
│ ├─────────────────────────────────┤│
│ │ Host OS (宿主操作系统) ││
│ ├─────────────────────────────────┤│
│ │ 物理硬件 ││
│ └─────────────────────────────────┘特点：
- 容器共享宿主操作系统内核（通常只有几十MB到几百MB）
- 启动快（几秒钟）
- 资源占用小
- 隔离性足够
对比表格
| 特性 | 虚拟机 | Docker容器 |
|---|---|---|
| 启动时间 | 分钟级 | 秒级 |
| 磁盘占用 | GB级 | MB级 |
| 性能 | 接近原生 | 接近原生 |
| 隔离性 | 完全隔离 | 进程级隔离 |
| 迁移成本 | 较高 | 很低 |
二、Docker核心组件详解
Docker有三个核心概念：镜像 、容器 、仓库。让我们逐一理解。
2.1 镜像 - "软件的安装包"
定义： 镜像是一个只读的模板，包含了运行程序所需的所有内容：代码、运行时、库、环境变量和配置文件。
生活类比： 镜像就像一张"光盘"或一个"软件安装包"。你可以用同一张光盘在多台电脑上安装相同的软件。
技术特点：
- 只读，不可修改
- 分层存储
- 可以通过Dockerfile创建
实例：
# 拉取一个Python镜像
docker pull python:3.9
# 这个镜像包含：
# - 一个精简的Linux系统
# - Python 3.9解释器
# - pip包管理工具镜像分层结构示意：
┌─────────────────────────────┐
│ 应用代码层 ← 你的Python代码
├─────────────────────────────┤
│ 依赖库层 ← 你安装的第三方库
├─────────────────────────────┤
│ Python运行环境层 ← Python解释器
├─────────────────────────────┤
│ 基础操作系统层 ← 精简的Linux
└─────────────────────────────┘2.2 容器 - "运行中的镜像实例"
定义： 容器是镜像的运行实例。如果把镜像比作"类"，容器就是"对象"。
生活类比：
- 镜像 = 菜谱（静态的，可以复制）
- 容器 = 按照菜谱做出来的菜（动态的，可以吃）
技术特点：
- 可读可写
- 相互隔离
- 生命周期：创建→运行→停止→删除
实例：
# 从镜像创建并运行一个容器
docker run -d --name my-python-app python:3.9
# 查看正在运行的容器
docker ps
# 停止容器
docker stop my-python-app
# 启动已停止的容器
docker start my-python-app
# 删除容器
docker rm my-python-app容器与镜像的关系：
docker run
┌─────────┐ ──────────────────→ ┌─────────────┐
│ 镜像 │ │ 容器实例1 │
│ (只读) │ ──────────────────→ │ (可读写) │
│ │ docker run └─────────────┘
└─────────┘
...
┌─────────────┐
│ 容器实例N │
│ (可读写) │
└─────────────┘2.3 仓库 - "镜像的存储中心"
定义： 仓库是集中存放镜像的地方，类似于代码仓库或应用商店。
生活类比： Docker Hub就像"应用商店"，你可以从中下载各种软件的镜像。
主要仓库：
- Docker Hub（官方，最常用）：https://hub.docker.com
- 阿里云镜像仓库（国内访问快）
- 私有仓库（企业内部使用）
实例：
# 从Docker Hub拉取镜像
docker pull nginx:latest
# 搜索镜像
docker search redis
# 登录Docker Hub
docker login
# 推送自己的镜像到仓库
docker push myusername/myimage:v1.0三、Docker架构详解
3.1 整体架构图
┌────────────────────────────────────────────────────────┐
│ Docker 架构图 │
├────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────────────────────────────────────────┐ │
│ │ Docker Client (客户端) │ │
│ │ docker命令行工具 │ │
│ └────────────────────┬─────────────────────────────┘ │
│ │ docker run, build, pull... │
│ ↓ │
│ ┌──────────────────────────────────────────────────┐ │
│ │ REST API (通信接口) │ │
│ └────────────────────┬─────────────────────────────┘ │
│ │ │
│ ↓ │
│ ┌──────────────────────────────────────────────────┐ │
│ │ Docker Daemon (守护进程) │ │
│ │ dockerd - 核心服务 │ │
│ │ ┌────────────────────────────────────────────┐ │ │
│ │ │ containerd - 容器生命周期管理 │ │ │
│ │ │ runc - 容器运行时 │ │ │
│ │ └────────────────────────────────────────────┘ │ │
│ └────────────────────┬─────────────────────────────┘ │
│ │ │
│ ↓ │
│ ┌──────────────────────────────────────────────────┐ │
│ │ 底层操作系统 │ │
│ │ Linux Kernel (Namespaces, Cgroups) │ │
│ └──────────────────────────────────────────────────┘ │
└────────────────────────────────────────────────────────┘3.2 Docker引擎
Docker引擎是一个客户端-服务器应用程序，包含以下组件：
核心组件：
| 组件 | 作用 | 类比 |
|---|---|---|
| Docker Client | 用户与Docker交互的界面 | 汽车的方向盘和仪表盘 |
| Docker Daemon | 后台服务，处理请求 | 汽车的发动机 |
| REST API | 客户端和守护进程之间的通信协议 | 汽车的电路系统 |
3.3 Docker Daemon（dockerd）
定义： Docker守护进程，是Docker的核心后台服务。
职责：
- 监听Docker API请求
- 管理镜像、容器、网络、存储卷
- 与其他守护进程通信以管理Docker服务
工作流程示例：
用户输入: docker run nginx
↓
Docker Client 解析命令
↓
通过REST API发送请求给Docker Daemon
↓
Docker Daemon检查本地是否有nginx镜像
↓ (如果没有)
从Docker Hub下载镜像
↓
创建容器
↓
启动容器
↓
返回结果给用户3.4 Docker CLI（命令行界面）
定义： 用户与Docker交互的主要方式。
常用命令分类：
# 镜像相关
docker images # 列出本地镜像
docker pull <镜像名> # 拉取镜像
docker rmi <镜像ID> # 删除镜像
docker build -t <名称> . # 构建镜像
# 容器相关
docker ps # 列出运行中的容器
docker ps -a # 列出所有容器
docker run <镜像名> # 创建并运行容器
docker stop <容器ID> # 停止容器
docker rm <容器ID> # 删除容器
# 日志和调试
docker logs <容器ID> # 查看容器日志
docker exec -it <容器ID> /bin/bash # 进入容器内部
# 系统信息
docker info # 查看Docker系统信息
docker version # 查看Docker版本四、容器化的优势详解
4.1 轻量性
原理： 容器共享宿主操作系统内核，不需要运行完整的操作系统。
具体体现：
虚拟机启动流程：
开机 → BIOS自检 → 引导加载 → 内核启动 → 系统服务启动 → 应用启动
(需要几分钟)
容器启动流程：
创建命名空间 → 资源隔离 → 应用启动
(只需几秒钟)资源对比实例：
| 项目 | 虚拟机 | Docker容器 |
|---|---|---|
| 基础镜像大小 | 10-20GB | 100-300MB |
| 内存占用 | 1-2GB起步 | 50-200MB |
| 启动时间 | 1-3分钟 | 1-5秒 |
| CPU开销 | 需要虚拟化层 | 几乎无额外开销 |
实际案例：
# 一个Alpine Linux容器只有5MB
docker pull alpine
docker images alpine
# REPOSITORY TAG IMAGE ID SIZE
# alpine latest 05455a08881e 5.56MB4.2 可移植性
定义： 容器可以在任何支持Docker的环境中运行，不受底层基础设施影响。
"一次构建，到处运行"：
┌─────────────────────────────────────────────────────┐
│ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ 开发电脑 │ │ 测试服务器│ │ 生产环境 │ │
│ │(Windows)│ │ (Linux) │ │ (云服务器)│ │
│ └────┬────┘ └────┬────┘ └────┬────┘ │
│ │ │ │ │
│ └─────────────┼─────────────┘ │
│ │ │
│ ┌──────┴──────┐ │
│ │ 相同的容器 │ │
│ │ 相同的行为 │ │
│ └─────────────┘ │
└─────────────────────────────────────────────────────┘实际操作示例：
# 在开发机器上打包应用
docker build -t myapp:v1.0 .
docker save -o myapp.tar myapp:v1.0
# 传输到生产服务器
scp myapp.tar user@production-server:/home/user/
# 在生产服务器上加载并运行
docker load -i myapp.tar
docker run -d -p 80:80 myapp:v1.04.3 一致性
定义： 开发、测试、生产环境完全一致，消除"环境配置问题"。
传统开发的问题：
开发环境: Python 3.9 + Django 4.0 + PostgreSQL 14
↓
测试环境: Python 3.8 + Django 3.2 + PostgreSQL 13 ← 版本不一致！
↓
生产环境: Python 3.7 + Django 3.1 + PostgreSQL 12 ← 又不同！
↓
结果: "在我的机器上能运行！"使用Docker后：
开发环境: Docker容器
↓
测试环境: 相同的Docker容器
↓
生产环境: 相同的Docker容器
↓
结果: 环境完全一致，问题大幅减少！Dockerfile保证一致性：
# Dockerfile - 定义环境的"配方"
FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["python", "app.py"]无论在哪里构建，都会得到完全相同的环境。
4.4 隔离性
定义： 容器之间相互隔离，互不影响。
底层技术：
Docker使用Linux内核的两个特性实现隔离：
1. Namespaces（命名空间）- 资源隔离
┌──────────────────────────────────────────────────────────────┐
│ Namespaces 隔离示意 │
├──────────────────────────────────────────────────────────────┤
│ │
│ 容器A 容器B │
│ ┌────────────────────┐ ┌────────────────────┐ │
│ │ PID NS: 1-100 │ │ PID NS: 1-100 │ │ ← 进程隔离
│ │ NET NS: 独立网络 │ │ NET NS: 独立网络 │ │ ← 网络隔离
│ │ MNT NS: 独立文件系统│ │ MNT NS: 独立文件系统│ │ ← 文件系统隔离
│ │ USER NS: 独立用户 │ │ USER NS: 独立用户 │ │ ← 用户隔离
│ └────────────────────┘ └────────────────────┘ │
│ │
│ 每个容器都认为自己拥有独立的系统资源 │
└──────────────────────────────────────────────────────────────┘2. Cgroups（控制组）- 资源限制
# 限制容器资源使用
docker run -d \
--name my-container \
--memory="512m" \ # 限制内存使用
--cpus="1.5" \ # 限制CPU使用
--memory-swap="1g" \ # 限制交换内存
nginx隔离性实例：
# 运行两个完全独立的容器
docker run -d --name web1 -p 8081:80 nginx
docker run -d --name web2 -p 8082:80 nginx
# 它们各自独立运行，互不干扰
# 即使web1崩溃，web2仍然正常运行
docker stop web1
docker ps # web2仍在运行五、动手实践：第一个Docker容器
让我们通过一个简单的例子，把前面学到的知识串联起来。
5.1 安装Docker
Windows系统：
-
下载Docker Desktop: https://www.docker.com/products/docker-desktop
-
安装并启动Docker Desktop
-
打开PowerShell，验证安装：
docker --version
Docker version 24.0.7, build afdd53b
📌安装过程如果遇到提示需要虚拟化环境等问题，可以参考更详细的安装文档：
https://blog.csdn.net/2501_90561511/article/details/145846039
5.2 运行第一个容器
# 运行一个简单的Web服务器
docker run -d -p 8080:80 --name my-web nginx
# docker run：创建 + 启动容器（一步完成）
# 参数解释：
# -d: 后台运行
# -p 8080:80: 将容器的80端口映射到主机的8080端口
# --name my-web: 给容器命名
# nginx: 使用的镜像名称✏️Nginx 是一款高性能、轻量级的 Web 服务器 & 反向代理服务器，现在几乎是互联网后端标配。
5.3 查看和管理容器
# 查看运行中的容器
docker ps
# 查看容器详细信息
docker inspect my-web
# 查看容器日志
docker logs my-web
# 进入容器内部
docker exec -it my-web /bin/bash
# 退出容器使用命令或者Ctrl + D
exit
# 停止容器
docker stop my-web
# 启动容器
docker start my-web
# 删除容器
docker rm -f my-web六、本周学习总结
核心概念回顾
┌─────────────────────────────────────────────────────┐
│ Docker 核心概念图 │
├─────────────────────────────────────────────────────┤
│ │
│ ┌──────────┐ docker pull ┌──────────┐ │
│ │ 仓库 │ ────────────────→ │ 镜像 │ │
│ │(Registry)│ │ (Image) │ │
│ └──────────┘ └────┬─────┘ │
│ ↑ │ │
│ │ docker push │ docker run │
│ │ ↓ │
│ ┌──────────┐ ┌──────────┐ │
│ │ 镜像 │ ←──────────────── │ 容器 │ │
│ │ (Image) │ docker commit │(Container)│ │
│ └──────────┘ └──────────┘ │
│ │ │
│ │ docker rm │
│ ↓ │
│ ┌──────────┐ │
│ │ 删除 │ │
│ └──────────┘ │
└─────────────────────────────────────────────────────┘本周学习检查清单
- 理解容器与虚拟机的区别
- 掌握镜像、容器、仓库的概念
- 了解Docker架构和各组件作用
- 理解容器化的四大优势
- 成功安装Docker并运行第一个容器
- 熟练使用基本的Docker命令
下周预告
下周我们将学习：
- Dockerfile的编写
- 镜像的构建与优化
- Docker网络基础
- 数据卷的使用
七、常见问题解答
Q1: Docker只能在Linux上运行吗？
A: Docker最初是为Linux设计的，但现在：
- Windows: 通过WSL2（Windows Subsystem for Linux）运行
- Mac: 通过Docker Desktop运行
- 底层都使用了轻量级的Linux虚拟机
Q2: 容器和镜像有什么区别？
A: 简单来说：
- 镜像是静态的"模板"，只读
- 容器是镜像的"运行实例"，可读写
- 一个镜像可以创建多个容器
Q3: Docker和Kubernetes是什么关系？
A:
- Docker负责创建和管理单个容器
- Kubernetes负责管理大规模的容器集群
- 可以理解为：Docker是"士兵"，Kubernetes是"指挥官"
📖课外了解
🐳 Docker 与 GitHub 的核心关系详解
Docker 和 GitHub 是现代云原生开发中深度绑定、互补共生的两大工具，二者从开源协作、镜像托管到 CI/CD 自动化形成了完整的开发生态闭环，核心关系可分为以下 4 个维度：
一、本源关系：Docker 诞生于 GitHub 开源生态
Docker 本身就是一个在 GitHub 上孵化的开源项目：
- Docker 于 2013 年以 Apache 2.0 协议开源，核心代码（Moby 项目）全程在 GitHub 维护，是全球最活跃的开源项目之一，累计超 6 万 Star、数万社区贡献者。
- Docker 官方的所有工具、文档、组件（如 Docker Engine、Docker Compose、Buildx）的源代码，均托管在 GitHub 的
docker组织下，开发者可直接提交 Issue、PR 参与迭代GitHub。 - 简单来说：GitHub 是 Docker 的 "诞生地" 和核心协作平台，没有 GitHub 就没有 Docker 今天的社区生态。
二、核心集成 1：GitHub 提供 Docker 镜像托管服务
GitHub 内置了 Docker 镜像仓库，可完全替代 Docker Hub：
1. GitHub Container Registry (GHCR)
- 专为容器镜像设计的托管服务，支持公开 / 私有镜像，与 GitHub 账号、权限体系深度打通，可直接用 GitHub 账号登录、拉取 / 推送镜像。
- 支持细粒度权限控制，可针对组织、仓库、团队配置镜像访问权限，适合企业内部私有镜像管理。
2. GitHub Packages
- 通用包托管服务，原生支持 Docker 镜像格式，可将 Docker 镜像与代码仓库绑定，实现代码与镜像的版本同步管理。
- 认证方式统一：使用 GitHub Personal Access Token（PAT）即可完成
docker login，无需额外注册第三方仓库账号。
三、核心集成 2：GitHub Actions 实现 Docker 全流程自动化
GitHub Actions 是 GitHub 内置的 CI/CD 工具，与 Docker 是云原生开发的 "黄金搭档"，可实现从代码提交到部署的全自动化：
1. 官方 Actions 组件
Docker 官方提供了一系列开箱即用的 GitHub Actions，直接集成到流水线中：
docker/login-action：自动登录 Docker Hub/GHCR 等镜像仓库docker/build-push-action：自动构建、打标签、推送 Docker 镜像docker/setup-buildx-action：配置多架构镜像构建环境docker/setup-compose-action：自动部署 Docker Compose 应用Docker
2. 典型自动化流程
plaintext
开发者 git push 代码 → 触发 GitHub Actions → 自动构建 Docker 镜像 → 漏洞扫描 → 推送至 GHCR/Docker Hub → 自动部署到服务器/K8s 集群- 彻底解决 "本地环境不一致" 问题，所有镜像在统一的 GitHub runners 中构建，保证一致性。
- 支持按分支、标签、定时等规则触发，实现开发、测试、生产环境的自动化发布。