从硬件到容器

一、总览：从硬件到容器的完整分层

+-------------------------------------------------------------------+
    应用程序 / 服务
    MySQL / Nginx / Redis / Java / Python
+-------------------------------------------------------------------+
    容器平台 (可选)
    Docker / containerd / Podman / Kubernetes
+-------------------------------------------------------------------+
    Linux 用户空间: 容器运行时
    runc
+-------------------------------------------------------------------+
    Linux 用户空间: 基础组件
    shell / libc / systemd / coreutils
+-------------------------------------------------------------------+
    Linux 内核空间
    - 五大子系统: 进程管理 / 内存管理 / 文件系统 / 网络子系统 / 设备与驱动
    - 增强机制: Namespaces / cgroups / UnionFS / KVM
+-------------------------------------------------------------------+
    硬件层
    CPU / 内存 / 硬盘 / 网卡
+-------------------------------------------------------------------+

二、硬件层：一切资源的源头

1️⃣ CPU

提供指令执行能力
提供多核、多 NUMA 节点
提供特权级（用户态 / 内核态）

内核如何使用 CPU

进程调度器决定 哪个进程在哪个 CPU 上运行
中断处理、软中断、调度时钟

2️⃣ 内存（RAM）

提供物理内存页
NUMA 架构决定访问延迟

内核如何使用内存

页分配、页回收
虚拟内存、页表
OOM Killer

3️⃣ 硬盘（Disk）

提供持久化存储
块设备接口

内核如何使用硬盘

块层调度
文件系统驱动
缓存页（Page Cache）

4️⃣ 网卡（NIC）

提供网络收发能力
中断触发数据处理

内核如何使用网卡

网络协议栈
中断 / NAPI
Socket 接口

三、Linux 内核空间：资源的“管理者”

五大核心子系统（根基）

1️⃣ 进程管理

进程创建、销毁
调度
信号
PID

2️⃣ 内存管理

虚拟内存
页缓存
NUMA
OOM

3️⃣ 文件系统

VFS
各类文件系统（ext4、xfs、overlayfs）

4️⃣ 网络子系统

TCP/IP 协议栈
Socket
Netfilter

5️⃣ 设备与驱动

块设备
字符设备
中断管理

内核增强机制（不是子系统）

namespaces（隔离视图）

隔离对象	依赖子系统
PID	进程管理
网络	网络子系统
挂载	文件系统
用户	进程管理

-> 决定“你看到什么”

cgroups（资源限制）

资源	子系统
CPU	进程管理
内存	内存管理
IO	文件系统
网络	网络子系统

-> 决定“你能用多少”

UnionFS / overlayfs

文件系统层叠
只读镜像 + 可写层

-> 文件系统子系统内部机制

NUMA

感知硬件内存拓扑
影响调度、内存分配

-> 内存管理 + 进程管理

四、Linux 用户空间基础组件

1️⃣ libc

作用：

系统调用封装
提供标准 C 接口

应用 不直接调用内核，而是通过 libc

2️⃣ shell

作用：

命令解释器
启动进程
管道、重定向

shell 本质是一个普通进程

3️⃣ systemd

作用：

系统初始化
服务管理
cgroups 管理者

systemd 是 系统级进程编排器

五、Linux 系统整体角色

Linux 系统 =

内核 + 用户空间工具 + 服务管理 + 配置体系

它的核心职责是：

管理硬件
提供稳定接口
支撑应用运行

六、虚拟化：在硬件之上再抽一层

虚拟化的本质

硬件
  ↓
Hypervisor（KVM）
  ↓
虚拟机（完整 Linux）

每个虚拟机都有自己的内核
资源隔离靠硬件虚拟化

内核在虚拟化中的角色

KVM 是内核模块
调度虚拟 CPU
管理内存映射

七、容器化：不虚拟内核，只虚拟“使用方式”

容器的本质

进程 + namespaces + cgroups + rootfs

Linux 内核
  ├─ namespace：看不见别人
  ├─ cgroups：用不多资源
  ├─ overlayfs：独立文件系统

runc：关键纽带

runc 做了什么

创建进程
配置 namespaces
绑定 cgroups
切换 rootfs
exec 应用

Docker 在其中的位置

Docker
 └─ containerd
     └─ runc
         └─ Linux 内核

Docker 不做隔离，Docker 调用内核做隔离。

八、最终统一关系图（强烈建议记住）

硬件
  ↓
Linux 内核（五大子系统）
  ↓
namespaces / cgroups / UnionFS / NUMA
  ↓
libc / shell / systemd
  ↓
runc
  ↓
Docker / Kubernetes
  ↓
应用程序

九、一句话终极总结

硬件提供资源
内核管理资源
namespaces 隔离视图
cgroups 限制额度
UnionFS 组织文件
libc / shell / systemd 使用内核
runc 组合内核能力
Docker / 容器 是进程的高级用法
虚拟机 是内核的复制品

☘️ Linux 架构心智模型图

目标：一眼就能看懂 Linux / 容器 / 虚拟化 / Docker 的全部关系

┌────────────────────────────────────────────────────┐
│                    应用程序                         │
│      MySQL / PostgreSQL / Nginx / Java / Python    │
└────────────────────────────────────────────────────┘
                           ▲
                           │ 进程 / 系统调用
┌────────────────────────────────────────────────────┐
│          容器平台（可选的一层抽象）                    │
│        Docker / Podman / Kubernetes                │
│        （镜像、网络、编排、生命周期）                   │
└────────────────────────────────────────────────────┘
                           ▲
                           │ OCI 接口
┌────────────────────────────────────────────────────┐
│              容器运行时（用户空间）                   │
│                       runc                         │
│  - 创建进程                                         │
│  - 设置 namespaces（隔离）                           │
│  - 设置 cgroups（限制）                              │
│  - 切换 rootfs（overlayfs）                         │
└────────────────────────────────────────────────────┘
                           ▲
                           │ libc 系统调用封装
┌────────────────────────────────────────────────────┐
│              Linux 用户空间基础                      │
│                                                    │
│  shell        -> 命令解释 / 启动进程                   │
│  libc         -> 系统调用接口                         │
│  systemd      -> 系统初始化 / 服务 / cgroups 管理      │
│  coreutils    -> 基础工具                            │
└────────────────────────────────────────────────────┘
                           ▲
                           │ 用户态 ↔ 内核态
┌────────────────────────────────────────────────────┐
│                  Linux 内核空间                     │
│                                                    │
│  ┌────────────── 五大核心子系统 ──────────────┐      │
│  │ 进程管理  │ 调度 / PID / 信号              │      │
│  │ 内存管理  │ 虚拟内存 / 页缓存 / OOM / NUMA  │      │
│  │ 文件系统  │ VFS / ext4 / xfs / overlayfs  │      │
│  │ 网络子系统│ TCP/IP / netfilter / socket   │      │
│  │ 设备驱动  │ 磁盘 / 网卡 / 中断              │      │
│  └──────────────────────────────────────────┘      │
│                                                    │
│  ┌────────────── 内核增强机制 ────────────────┐      │
│  │ namespaces -> 进程“看到的世界”隔离           │      │
│  │ cgroups    -> CPU / 内存 / IO / 网络限制    │      │
│  │ UnionFS    -> 文件系统层叠（overlayfs）      │     │
│  │ NUMA       -> 硬件内存拓扑感知               │     │
│  └──────────────────────────────────────────┘      │
└────────────────────────────────────────────────────┘
                           ▲
                           │ 驱动 / 中断 / DMA
┌────────────────────────────────────────────────────┐
│                      硬件层                         │
│          CPU / 内存 / 硬盘 / 网卡                    │
└────────────────────────────────────────────────────┘

📌 快速理解（只看这几行也够）

硬件：提供真实资源
Linux 内核：管理和抽象资源
五大子系统：内核的基础能力
namespaces：隔离“你看到什么”
cgroups：限制“你能用多少”
UnionFS / overlayfs：组织容器文件系统
libc / shell / systemd：使用内核能力
runc：把隔离 + 限制 + 文件系统拼成“容器进程”
Docker / Kubernetes：在 runc 之上的工程化平台

🎯 一句话终极心智模型

容器不是虚拟机 容器是：Linux 内核 + 一组受限、被隔离的进程