网络存储与安全体系深度解析

你的 Pod 跑起来了,kubectl get pod 显示 Running。但从另一个 Node 上的 Pod 访问它却超时。你 exec 进 Pod 发现 curl localhost:8080 正常,但 curl <PodIP>:8080 从其他 Node 不通。问题到底出在哪一层——是 CNI 没配好路由?是 iptables 规则有问题?还是 NetworkPolicy 挡住了?

网络是 K8s 最复杂的子系统。本篇从一个数据包的完整旅程出发,让你理解 Pod 网络建立、Service 转发、DNS 解析、Ingress 路由的每一跳;再深入存储和安全体系的核心机制。


1. Kubernetes 网络模型

1.1 为什么需要"扁平网络"?

要理解 K8s 的网络模型,先看看没有它的世界。

Docker 原生网络的问题:每个 Docker 主机有一个 docker0 bridge,容器通过 NAT 访问外部。两台主机上的容器要通信,需要端口映射:主机 A 上的容器暴露在 HostA:8080,主机 B 上的容器通过 HostA:8080 访问它。

这在 3 个容器时能工作。但当你有 500 个容器呢?

K8s 做了一个大胆的决定:干掉 NAT,给每个 Pod 一个真实的 IP。

这就是 K8s 网络模型的三条铁律:

  1. Pod-to-Pod:任何 Pod 可以不经过 NAT 直接和任何其他 Pod 通信
  2. Node-to-Pod:任何 Node 可以不经过 NAT 直接和任何 Pod 通信
  3. IP 一致性:Pod 自己看到的 IP = 别人看到的它的 IP

IP-per-Pod:每个 Pod 有独立 IP,Pod 内的所有容器共享这个 IP(通过共享 Network Namespace)。这意味着:

代价:这个美好的"扁平网络"在物理上并不存在——底层物理网络并不知道 Pod IP 的存在。所以需要有人在物理网络之上构建一个虚拟的扁平网络。这就是 CNI 插件的职责。

1.2 一个 Pod 的网络是怎么建立的?

让我们从一个 Pod 被调度到 Node 的那一刻开始,一步步看网络是怎么搭建的。

前提知识:Linux Network Namespace 是内核提供的网络隔离机制。每个 Namespace 有自己独立的网卡、路由表、iptables 规则。不同 Namespace 之间默认不通。

场景:Pod web-abc 被调度到 Node-1,CNI 插件是 Calico(使用 VXLAN 模式)。

kubelet 收到 apiserver 的通知:"你需要运行 Pod web-abc"
    │
    ▼
步骤 1:kubelet 调用 CRI(containerd)创建 Pod Sandbox
    │   containerd 做的第一件事:创建一个新的 Network Namespace
    │   此时这个 Namespace 里什么都没有——没有网卡、没有 IP、没有路由
    │
    ▼
步骤 2:containerd 调用 CNI 插件
    │   读取 /etc/cni/net.d/ 下的配置文件,找到 CNI 插件二进制文件
    │   执行 CNI ADD 命令,传入 Network Namespace 路径
    │
    ▼
步骤 3:CNI 插件创建 veth pair
    │
    │   veth pair 是 Linux 的虚拟网络设备——可以理解为一根"虚拟网线",
    │   一端插在 Pod 的 Network Namespace 里(叫 eth0),
    │   另一端插在 Node 的根 Network Namespace 里(叫 cali-xxxx)。
    │
    │   从 eth0 发出的包会从 cali-xxxx 出来,反过来也一样。
    │
    │   Node 根 Namespace                    Pod Namespace
    │   ┌─────────────────┐                 ┌──────────────┐
    │   │  cali-xxxx ◄────┼── veth pair ──► │  eth0        │
    │   │                 │                 │  10.244.1.5  │
    │   │  Node 的路由表   │                 │  路由表       │
    │   └─────────────────┘                 └──────────────┘
    │
    ▼
步骤 4:IPAM(IP Address Management)分配 IP
    │   CNI 插件调用 IPAM 模块,从 Pod CIDR 中分配一个 IP(如 10.244.1.5)
    │   把这个 IP 配置到 Pod 的 eth0 上
    │
    ▼
步骤 5:配置路由
    │   在 Pod 的 Namespace 里:
    │     default via 169.254.1.1 dev eth0
    │     (所有流量都通过 eth0 发出去)
    │
    │   在 Node 的根 Namespace 里:
    │     10.244.1.5 dev cali-xxxx scope link
    │     (发给 10.244.1.5 的包从 cali-xxxx 网卡送进去)
    │
    ▼
步骤 6:Pod 网络就绪
    kubelet 启动 Pod 中的容器
    Pod 的 IP 信息写入 Pod Status,上报给 apiserver

这就是为什么每个 Pod 都有独立 IP——每个 Pod 有自己的 Network Namespace 和 veth pair,CNI 插件为每个 Pod 分配唯一的 IP 并配置路由。

1.3 跨 Node 的 Pod 通信:数据包的完整旅程

IP 分配好了,同一个 Node 上的 Pod 通过 veth pair + 路由就能通信。但跨 Node 呢?Node-1 上的 Pod A(10.244.1.5)怎么把包发到 Node-2 上的 Pod B(10.244.2.8)?

底层物理网络只认 Node IP(如 192.168.1.10、192.168.1.11),不认 Pod IP(10.244.x.x)。所以 CNI 插件必须在 Node 之间建立一条"隧道"或通过路由通告让物理网络知道 Pod IP 怎么走。

方案一:VXLAN 隧道(Flannel/Calico VXLAN 模式)

Pod A (10.244.1.5) on Node-1 → Pod B (10.244.2.8) on Node-2

1. Pod A 发出包:src=10.244.1.5, dst=10.244.2.8
2. 包从 eth0 出来,通过 veth pair 到达 Node-1 的根 Namespace
3. Node-1 的路由表:10.244.2.0/24 via 192.168.1.11 dev vxlan.calico
   → 发给 10.244.2.x 网段的包走 VXLAN 隧道,对端是 Node-2(192.168.1.11)
4. VXLAN 封装:
   ┌──────────────────────────────────────────────────────┐
   │ 外层 IP: src=192.168.1.10, dst=192.168.1.11         │
   │ 外层 UDP: dstPort=4789 (VXLAN)                      │
   │ VXLAN Header: VNI=4096                              │
   │ ┌──────────────────────────────────────────────────┐ │
   │ │ 内层 IP: src=10.244.1.5, dst=10.244.2.8         │ │
   │ │ 内层 TCP: ...应用数据...                          │ │
   │ └──────────────────────────────────────────────────┘ │
   └──────────────────────────────────────────────────────┘
5. 物理网络只看到 Node-1 → Node-2 的 UDP 包——正常路由
6. 到达 Node-2 后,VXLAN 解封,取出内层包
7. Node-2 的路由表:10.244.2.8 dev cali-yyyy → 通过 veth pair 送入 Pod B

VXLAN 的优点:对底层网络完全无感——只要 Node 之间 UDP 能通就行,不需要网络管理员做任何配置。缺点:封装/解封有 CPU 开销,MTU 减少约 50 字节(原始包外面又套了一层 IP+UDP+VXLAN 头)。

方案二:BGP 路由通告(Calico BGP 模式)

思路完全不同——不隧道,而是让物理网络知道 Pod IP 怎么路由。

Calico 在每个 Node 上运行 BIRD(BGP daemon),向网络中通告路由:
  Node-1 通告:"10.244.1.0/24 从我这里走"
  Node-2 通告:"10.244.2.0/24 从我这里走"

如果网络设备(交换机/路由器)支持 BGP 并接受这些路由通告:
  物理路由器的路由表多了两条:
    10.244.1.0/24 → 192.168.1.10 (Node-1)
    10.244.2.0/24 → 192.168.1.11 (Node-2)

数据包路径:
1. Pod A (10.244.1.5) → veth → Node-1
2. Node-1 路由:10.244.2.0/24 via router
3. 物理路由器:10.244.2.0/24 → Node-2(BGP 学到的路由)
4. Node-2:10.244.2.8 → veth → Pod B

整个过程没有封装——原始包直接在三层路由中传输。

优点:零封装开销,性能最好。缺点:网络基础设施必须支持 BGP,环境要求高。

方案三:eBPF(Cilium)

Cilium 用 eBPF 程序直接在内核的网络栈中处理数据包,绕过了传统的 iptables/netfilter 路径。可以结合 VXLAN 或直接路由工作。核心优势不在隧道方式,而在内核态直接处理——省去了用户态代理的开销,延迟更低。但需要较新的 Linux 内核(≥5.4)。

选哪个?

场景 推荐
开发/测试、快速上手 Flannel(VXLAN,最简单)
生产环境通用 Calico(VXLAN 或 BGP,功能全面)
大规模、高性能、需要 L7 可观测 Cilium(eBPF)
网络基础设施支持 BGP Calico BGP 模式(最优性能)

1.4 Service 网络:从 Pod IP 到稳定的服务入口

Pod IP 有一个致命问题:它不稳定。Pod 被重建后 IP 就变了。你不能在应用代码里硬编码 Pod IP。

Service 提供了一个稳定的虚拟 IP(ClusterIP),后端是一组 Pod。当 Pod 增减时,Service 自动更新后端列表。客户端只需访问 ClusterIP,不用关心后端有几个 Pod、IP 是什么。

但 ClusterIP 在物理网络中并不存在——没有任何网卡配了这个 IP。那数据包发到这个"不存在的 IP"是怎么到达 Pod 的?

答案:kube-proxy 在每个 Node 上配置了 iptables/IPVS 规则,拦截发往 ClusterIP 的包,做 DNAT(目标地址替换)转发到某个 Pod IP。

iptables 模式的完整链路

让我们用一个真实场景走一遍。Service web-svc 有 ClusterIP 10.96.100.1:80,后端是 3 个 Pod。

当 Pod A 访问 10.96.100.1:80 时,数据包经过以下 iptables 规则链:

PREROUTING 链(或 OUTPUT 链,取决于流量方向)
    │
    ▼
KUBE-SERVICES 链
    │  匹配规则:-d 10.96.100.1 --dport 80 → 跳转到 KUBE-SVC-XXXXX
    │
    ▼
KUBE-SVC-XXXXX 链(Service 链)
    │  三条规则实现随机负载均衡:
    │
    │  规则 1: --probability 0.33333 → KUBE-SEP-AAAA
    │  规则 2: --probability 0.50000 → KUBE-SEP-BBBB
    │  规则 3:                       → KUBE-SEP-CCCC
    │
    │  概率计算:3 个后端
    │    第 1 条:1/3 = 33.3%
    │    第 2 条:在未被第 1 条匹配的 2/3 中选 1/2 = 50% × 2/3 = 33.3%
    │    第 3 条:剩余的 = 33.3%
    │  → 每个 Pod 获得均等的 1/3 概率
    │
    ▼
KUBE-SEP-AAAA 链(Endpoint 链)
    │  DNAT 规则:--to-destination 10.244.1.5:8080
    │  → 把目标地址从 10.96.100.1:80 替换为 Pod IP 10.244.1.5:8080
    │
    ▼
数据包继续正常路由到 10.244.1.5(通过 CNI 建立的路由)

你可以在 Node 上用 iptables-save 看到这些规则:

# 查看 Service 相关的 iptables 规则
iptables-save | grep "web-svc"
# 或更可读的方式
iptables -t nat -L KUBE-SERVICES -n | grep 10.96.100.1

iptables 模式的性能问题:规则数量 = O(Services × Endpoints)。1000 个 Service,每个 10 个 Pod = 10000 条 iptables 规则。而且 iptables 是线性匹配——数据包必须从第一条规则开始逐条检查。规则更新时需要全量替换——10000 条规则的替换操作可能需要几秒钟,期间可能丢包。

IPVS 模式:大规模集群的选择

IPVS(IP Virtual Server)是 Linux 内核的四层负载均衡模块,使用哈希表而不是链式规则匹配——查找性能 O(1)。

# 查看 IPVS 规则
ipvsadm -Ln
TCP  10.96.100.1:80 rr
  -> 10.244.1.5:8080     Masq   1    0    0
  -> 10.244.2.8:8080     Masq   1    0    0
  -> 10.244.3.12:8080    Masq   1    0    0

IPVS 额外支持多种负载均衡算法:

什么时候该从 iptables 切换到 IPVS? 经验值:当 Service 数量超过 1000 时,iptables 的性能开始成为瓶颈。小集群用 iptables 就够了。

Service 类型的递进关系

四种 Service 类型不是并列的——它们是层层叠加的:

graph TD
    A["ClusterIP(基础)
集群内部虚拟 IP"] B["NodePort
在每个 Node 开端口 30000-32767
外部可通过 NodeIP:NodePort 访问"] C["LoadBalancer
Cloud Controller 创建云 LB
LB → NodePort → ClusterIP → Pod"] D["ExternalName(特殊)
DNS CNAME 别名,指向外部域名"] A -->|"在 ClusterIP 基础上增加"| B B -->|"在 NodePort 基础上增加"| C D -.->|"独立机制"| A

每一层都是在上一层的基础上增加能力。理解了 ClusterIP 的 iptables 规则,就理解了所有类型的基础。

externalTrafficPolicy:一个影响源 IP 保留的关键配置

spec:
  type: NodePort
  externalTrafficPolicy: Local  # 或 Cluster(默认)

为什么需要这个配置? 看一个具体问题:

客户端(1.2.3.4)→ Node-1:30080 → kube-proxy DNAT → Pod(在 Node-2 上)

默认 Cluster 模式下,Node-1 收到包后可能把它转发到 Node-2 上的 Pod。问题:

  1. 多了一跳:数据包从 Node-1 转发到 Node-2,增加延迟
  2. 源 IP 丢失:Node-1 做 SNAT(把源 IP 从 1.2.3.4 替换为 Node-1 的 IP)——否则 Pod 的响应会直接从 Node-2 回到客户端,客户端收到一个它没有请求过的 IP 发来的包,连接断开。但 SNAT 后 Pod 看到的源 IP 是 Node-1 而不是 1.2.3.4——无法做基于 IP 的审计、限速

Local 模式:只把流量转发到本 Node 上的 Pod。好处:不 SNAT,源 IP 保留,少一跳。坏处:如果本 Node 上没有该 Service 的 Pod,流量直接被丢弃——负载不均衡。

1.5 Endpoints 与 EndpointSlice

Service 怎么知道后端有哪些 Pod?通过 Endpoints 对象。每当 Pod 的 Ready 状态变化,Endpoint Controller 自动更新 Endpoints 对象。

但 Endpoints 有一个大规模下的性能问题:一个 Endpoints 对象存储 Service 的所有后端。当 Service 有 5000 个 Pod 时:

EndpointSlice(K8s 1.21 GA) 解决了这个问题:将 endpoints 分片存储,每个 slice 默认最多 100 个 endpoint。

Service "web" (5000 个 Pod)
    ├── EndpointSlice "web-abc12" (endpoints 1-100)
    ├── EndpointSlice "web-def34" (endpoints 101-200)
    ├── ...
    └── EndpointSlice "web-xyz99" (endpoints 4901-5000)

Pod 变化时,只需更新包含该 Pod 的那一个 slice(100 个 endpoint 的数据量),而不是全部 5000 个。数据传输量减少 50 倍。

1.6 DNS(CoreDNS)

Service 的 DNS 记录

K8s 通过 CoreDNS 为每个 Service 自动创建 DNS 记录:

# ClusterIP Service
my-svc.my-ns.svc.cluster.local → ClusterIP(A 记录)

# Headless Service(clusterIP: None)
my-svc.my-ns.svc.cluster.local → 所有 Pod IP(多条 A 记录)
pod-0.my-svc.my-ns.svc.cluster.local → 特定 Pod IP

# ExternalName Service
my-svc.my-ns.svc.cluster.local → CNAME external.example.com

ndots 问题:一个隐蔽的性能杀手

Pod 的 /etc/resolv.conf 默认长这样:

nameserver 10.96.0.10        # CoreDNS 的 ClusterIP
search default.svc.cluster.local svc.cluster.local cluster.local
options ndots:5

ndots:5 的含义:如果域名中的点(.)少于 5 个,先在 search 域中逐个拼接查找。

当你的应用访问 api.example.com(2 个点 < 5)时,实际的 DNS 查询序列:

1. api.example.com.default.svc.cluster.local    → NXDOMAIN
2. api.example.com.svc.cluster.local             → NXDOMAIN
3. api.example.com.cluster.local                 → NXDOMAIN
4. api.example.com                               → 解析成功

4 次查询才成功——前 3 次全是浪费! 如果你的应用频繁调用外部 API,这些无效 DNS 查询会给 CoreDNS 带来巨大负载。

解决方案:

  1. 使用 FQDN(末尾加 .):api.example.com. ——告诉解析器"这是绝对域名,不要拼接 search 域"
  2. 降低 ndots:ndots: 2 适合大多数场景(大部分外部域名至少有 2 个点)
  3. NodeLocal DNSCache:在每个 Node 上运行 DNS 缓存(DaemonSet),第一次查询后缓存结果,后续查询不再到 CoreDNS
# 在 Pod spec 中降低 ndots
spec:
  dnsConfig:
    options:
    - name: ndots
      value: "2"

2. Ingress 与 Gateway API

2.1 为什么需要 Ingress?

Service 的 NodePort 和 LoadBalancer 类型可以把集群内的服务暴露到外部。但它们工作在 L4(TCP/UDP)——不理解 HTTP。

现实场景中你需要的是:

每个 Service 都创建一个 LoadBalancer?你会有几十个公网 IP 和负载均衡器——贵且难管。

Ingress 的思路:用一个负载均衡器(Ingress Controller)处理所有入站 HTTP 流量,根据域名和路径路由到不同的后端 Service。

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: web-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  ingressClassName: nginx
  tls:
  - hosts: [web.example.com]
    secretName: web-tls
  rules:
  - host: web.example.com
    http:
      paths:
      - path: /api
        pathType: Prefix
        backend:
          service:
            name: api-service
            port:
              number: 80
      - path: /
        pathType: Prefix
        backend:
          service:
            name: frontend
            port:
              number: 80

Ingress 本身只是一个声明——"我希望这样路由"。真正干活的是 Ingress Controller(如 Nginx Ingress Controller),它 Watch Ingress 对象,自动生成 Nginx 配置并 reload。

路径匹配规则

pathType 行为 示例
Exact 精确匹配 /foo 只匹配 /foo,不匹配 /foo/
Prefix 前缀匹配(按 / 分段) /foo 匹配 /foo、/foo/bar,不匹配 /foobar
ImplementationSpecific 由 Ingress Controller 决定 取决于具体实现

2.2 Gateway API:Ingress 的演进

Ingress 用了几年后,社区发现了它的硬伤:

  1. 功能全靠 annotation hack:流量分割?nginx.ingress.kubernetes.io/canary-weight: "10"。限速?又一个 annotation。不同 Ingress Controller 的 annotation 完全不兼容——从 Nginx 换到 Traefik,所有 annotation 都得改。

  2. 只有一层抽象:谁能创建 Ingress?谁能配置 TLS?谁能定义路由?全混在一起。基础设施团队和应用开发者的关注点没有分离。

  3. 只支持 HTTP/HTTPS:gRPC、TCP、UDP 路由无法通过标准 Ingress 表达。

Gateway API 是 Ingress 的下一代(K8s SIG-Network 官方项目),用三层资源模型解决这些问题:

graph TD
    A["GatewayClass(基础设施管理员)
定义网关实现:Istio / Envoy / Nginx"] B["Gateway(集群运维)
部署网关实例,监听端口,配置 TLS"] C["HTTPRoute / GRPCRoute / TCPRoute(应用开发者)
定义路由规则:路径匹配、流量分割"] A --> B --> C
# 应用开发者只需关心路由规则
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: web-route
spec:
  parentRefs:
  - name: production-gateway
  hostnames: ["web.example.com"]
  rules:
  - matches:
    - path:
        type: PathPrefix
        value: /api
    backendRefs:
    - name: api-service
      port: 80
      weight: 90
    - name: api-service-canary
      port: 80
      weight: 10            # 内置流量分割!不需要 annotation

核心优势:


3. Service Mesh

3.1 Service Mesh 解决什么问题?

当你有 50 个微服务互相调用时,每个服务都需要处理:

如果每个服务自己实现这些,那每种语言(Go、Java、Python、Node.js)都得写一遍——而且还得保证行为一致。

Service Mesh 的核心思路:把这些网络层面的能力下沉到基础设施层。在每个 Pod 旁边放一个 Sidecar 代理(通常是 Envoy),所有进出流量都经过它。应用代码不需要任何修改。

Pod 内部:
┌─────────────────────────────────────┐
│  App Container ←→ Sidecar (Envoy)  │
│  只管业务逻辑      处理重试/熔断/mTLS/... │
└─────────────────────────────────────┘

Sidecar 怎么拦截所有流量?通过 iptables 规则重定向——Init Container 在 Pod 启动时配置 iptables,把所有进出流量劫持到 Envoy 的端口。应用完全无感知。

3.2 Istio 核心能力

Istio 是最流行的 Service Mesh 实现。

流量管理——用 VirtualService 定义精细的路由规则:

apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: reviews
spec:
  hosts: [reviews]
  http:
  - match:
    - headers:
        end-user:
          exact: jason        # 特定用户路由到 v2(A/B 测试)
    route:
    - destination:
        host: reviews
        subset: v2
  - route:
    - destination:
        host: reviews
        subset: v1
      weight: 90              # 90% 流量到 v1
    - destination:
        host: reviews
        subset: v3
      weight: 10              # 10% 金丝雀到 v3

异常检测(熔断)——自动摘除不健康的后端:

apiVersion: networking.istio.io/v1beta1
kind: DestinationRule
metadata:
  name: reviews
spec:
  host: reviews
  trafficPolicy:
    connectionPool:
      tcp:
        maxConnections: 100
    outlierDetection:
      consecutive5xxErrors: 5     # 连续 5 个 5xx 错误
      interval: 30s               # 每 30 秒检测
      baseEjectionTime: 30s       # 摘除 30 秒

mTLS(服务间加密)——Sidecar 自动处理证书签发、轮换,应用完全不用管:

apiVersion: security.istio.io/v1beta1
kind: PeerAuthentication
metadata:
  name: default
  namespace: production
spec:
  mtls:
    mode: STRICT     # 所有通信必须 mTLS

3.3 Sidecar 模式 vs Sidecarless

传统 Sidecar 模式的代价:每个 Pod 多一个 Envoy 容器,消耗 ~50MB 内存和一些 CPU。100 个 Pod = 额外 5GB 内存。而且每个请求多了两次用户态代理(发送方 Sidecar + 接收方 Sidecar),增加延迟。

Cilium Service Mesh 走了另一条路:无 Sidecar。利用 eBPF 在内核层面直接实现 L4/L7 流量管理。优势是性能更好、资源消耗更少。缺点是需要较新内核(≥5.4),L7 功能不如 Envoy 成熟。

Linkerd 则用 Rust 编写的轻量代理(linkerd2-proxy)替代 Envoy,资源消耗更少,学习曲线更低,但功能不如 Istio 全面。


4. 存储体系

4.1 从问题出发:为什么需要这么多抽象?

容器的文件系统是临时的——容器重启后,之前写入的数据全没了。对 Web 服务器这类无状态应用不是问题,但对数据库、消息队列等有状态应用来说,这是灾难。

最简单的方案:把 Node 上的目录直接挂载到容器里(hostPath)。数据在 Node 磁盘上,容器重启数据还在。

问题:Pod 被重新调度到另一个 Node 怎么办?数据在旧 Node 上,新 Node 上什么都没有。而且谁来管理磁盘空间?谁来备份?不同的存储后端(NFS、Ceph、AWS EBS)有不同的 API,难道让应用开发者自己适配?

K8s 用四层抽象来解决这些问题:

graph TD
    A["应用开发者
只关心'我需要 10Gi 存储'"] B["PersistentVolumeClaim (PVC)
请给我 10Gi 的 ReadWriteOnce 存储"] C["PersistentVolume (PV)
一块具体的存储资源"] D["StorageClass
使用 AWS EBS gp3,在 us-east-1a 创建卷"] E["CSI Driver
实际的存储操作:创建卷、挂载、格式化"] A --> B -->|"自动绑定"| C -->|"由 StorageClass 定义如何创建"| D -->|"通过 CSI Driver 操作"| E

关注点分离:

4.2 Volume 的完整生命周期

让我们跟踪一个 PVC 从创建到 Pod 使用的全过程。

场景:开发者创建了一个需要持久存储的 Pod。

# 开发者写的 PVC
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: data-pvc
spec:
  storageClassName: fast-ssd
  accessModes: [ReadWriteOnce]
  resources:
    requests:
      storage: 50Gi
---
# Pod 引用 PVC
apiVersion: v1
kind: Pod
metadata:
  name: db
spec:
  containers:
  - name: mysql
    image: mysql:8.0
    volumeMounts:
    - name: data
      mountPath: /var/lib/mysql
  volumes:
  - name: data
    persistentVolumeClaim:
      claimName: data-pvc

背后发生了什么:

1. PVC 创建
   │  PVC 进入 Pending 状态
   │
   ▼
2. 动态供应(Dynamic Provisioning)
   │  PV Controller 发现 PVC 引用了 StorageClass "fast-ssd"
   │  调用 CSI Controller Plugin 的 CreateVolume RPC
   │  → CSI Driver 调用云 API 创建一块 50Gi 的 SSD 卷
   │  → 返回卷 ID(如 vol-abc123)
   │  → PV Controller 创建一个 PV 对象,和 PVC 绑定
   │  PVC 进入 Bound 状态
   │
   ▼
3. Pod 调度
   │  Scheduler 注意到 Pod 需要 PVC "data-pvc"
   │  PVC 绑定到的 PV 如果有拓扑约束(如 zone=us-east-1a),
   │  Scheduler 只会把 Pod 调度到该 zone 的 Node
   │
   ▼
4. ControllerPublishVolume(挂接)
   │  AD Controller 发现 Pod 调度到了 Node-1,但 Volume 还没挂接到 Node-1
   │  调用 CSI Controller Plugin 的 ControllerPublishVolume RPC
   │  → CSI Driver 调用云 API 把 EBS 卷 attach 到 Node-1 的 EC2 实例
   │  创建 VolumeAttachment 对象记录状态
   │
   ▼
5. NodeStageVolume(格式化 + 挂载到 staging 目录)
   │  kubelet 的 Volume Manager 调用 CSI Node Plugin
   │  → 检查卷是否需要格式化(第一次使用时格式化为 ext4/xfs)
   │  → 挂载到 Node 的一个 staging 目录(如 /var/lib/kubelet/plugins/xxx/staging)
   │  这一步的目的是:一个 Volume 可能被多个 Pod 使用(ReadWriteMany),
   │  先挂到 staging,再 bind mount 到每个 Pod 的目录
   │
   ▼
6. NodePublishVolume(bind mount 到 Pod 目录)
   │  kubelet 把 staging 目录 bind mount 到 Pod 的 Volume 目录
   │  → /var/lib/kubelet/pods/<pod-uid>/volumes/kubernetes.io~csi/data-pvc/mount
   │
   ▼
7. Pod 启动
   容器看到 /var/lib/mysql 里的数据——实际上是 EBS 卷里的内容

Pod 删除时反向操作:NodeUnpublishVolume → NodeUnstageVolume → ControllerUnpublishVolume → (如果 PVC 的 reclaimPolicy 是 Delete)DeleteVolume。

4.3 存储类型选择

本地存储

类型 持久性 调度感知 使用场景
emptyDir Pod 生命周期(Pod 删了数据就没了) 不支持 临时缓存、容器间共享数据
hostPath Node 持久(数据在 Node 磁盘上) 不支持 仅开发测试、DaemonSet
local PV Node 持久 支持(延迟绑定) 高性能本地 SSD

local PV vs hostPath 的关键区别:local PV 由 Scheduler 感知。Scheduler 知道"这个 PV 在 Node-3 上",会把 Pod 调度到 Node-3。hostPath 没有这个能力——Pod 可能被调度到 Node-5,那里根本没有数据。

分布式存储

方案 底层存储 特点
Rook-Ceph Ceph 功能最全(块/文件/对象),生产验证最充分,但运维复杂
Longhorn 本地磁盘 Rancher 出品,轻量简单,支持跨节点复制和快照
OpenEBS 本地磁盘 多引擎(cStor/Jiva/LocalPV),灵活度高

有状态应用怎么选?

应用类型 推荐存储 原因
数据库(MySQL/PostgreSQL) 云块存储 / local PV 高 IOPS、低延迟
消息队列(Kafka) local PV 极高吞吐量,Kafka 自带副本机制不需要存储层再做复制
文件共享(多 Pod 读写同一目录) NFS / CephFS 需要 ReadWriteMany
对象存储 MinIO(S3 兼容) 非结构化数据

4.4 Volume Snapshot 与备份

CSI 规范支持 Volume Snapshot——对 PVC 做快照,可以快速恢复数据:

# 创建快照
apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshot
metadata:
  name: data-snapshot
spec:
  volumeSnapshotClassName: csi-snapclass
  source:
    persistentVolumeClaimName: data-pvc

---
# 从快照恢复——创建一个新 PVC,数据源是快照
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: data-restored
spec:
  storageClassName: fast-ssd
  dataSource:
    name: data-snapshot
    kind: VolumeSnapshot
    apiGroup: snapshot.storage.k8s.io
  accessModes: [ReadWriteOnce]
  resources:
    requests:
      storage: 50Gi

对于完整的备份/恢复方案(不仅备份数据,还备份 K8s 资源定义),Velero 是标准工具:

# 备份整个 Namespace(K8s 资源 + PV 数据)
velero backup create prod-backup --include-namespaces production

# 定时备份
velero schedule create daily-backup --schedule="0 2 * * *" \
  --include-namespaces production

# 恢复
velero restore create --from-backup prod-backup

5. 安全体系

5.1 认证(Authentication):你是谁?

在你能做任何操作之前,apiserver 需要知道你是谁。K8s 支持多种认证方式,可以同时启用多个(任一通过即可):

方式 适用对象 机制
X.509 客户端证书 集群组件、管理员 TLS 双向认证,证书的 CN 是用户名、O 是组
ServiceAccount Token Pod 内应用 JWT Token 自动挂载到 Pod
OIDC 企业用户 对接 IdP(Keycloak/Dex/Google),SSO 登录
Webhook 自定义认证 把 Token 发给外部服务验证

Pod 怎么认证自己?——ServiceAccount Token

每个 Namespace 有一个 default ServiceAccount。Pod 启动时 kubelet 自动挂载 Token:

/var/run/secrets/kubernetes.io/serviceaccount/
  ├── token      ← JWT Token
  ├── ca.crt     ← 集群 CA 证书
  └── namespace  ← 当前 Namespace

K8s 1.22+ 的重要变化——Bound ServiceAccount Token:

旧版 Token 是永不过期的——一旦泄露,攻击者可以永久使用。新版 Token 有三个安全改进:

  1. 有过期时间(默认 1 小时,kubelet 自动轮换)
  2. 绑定到特定 Pod(Pod 删除后 Token 即失效)
  3. 绑定到特定 Audience(Token 只能用于特定目的)

5.2 授权(Authorization):你能做什么?

认证通过后,apiserver 需要判断你有没有权限执行这个操作。K8s 默认使用 RBAC(Role-Based Access Control)。

RBAC 的四个核心资源

graph LR
    subgraph Subject["谁(Subject)"]
        U[User]
        G[Group]
        SA[ServiceAccount]
    end
    subgraph Role["能做什么(Role)"]
        R["Role
Namespace 级别"] CR["ClusterRole
集群级别"] end subgraph Binding["怎么关联"] RB["RoleBinding
Namespace 级别"] CRB["ClusterRoleBinding
集群级别"] end U --> RB G --> RB SA --> CRB RB --> R RB --> CR CRB --> CR

一个常用但容易被忽略的模式:ClusterRole 可以通过 RoleBinding(不是 ClusterRoleBinding)绑定到特定 Namespace。这意味着你可以定义一次 ClusterRole,在不同 Namespace 中复用。

# 复用内置的 edit ClusterRole,限定在 development Namespace
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: dev-edit
  namespace: development
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole     # 引用 ClusterRole(不是 Role)
  name: edit             # K8s 内置 ClusterRole
subjects:
- kind: Group
  name: dev-team
  apiGroup: rbac.authorization.k8s.io

内置 ClusterRole

ClusterRole 权限
cluster-admin 超级管理员,所有权限
admin Namespace 管理员(不含 ResourceQuota 和 Namespace 本身的管理)
edit 读写大部分资源(不含 Role/RoleBinding——防止自己给自己提权)
view 只读(不含 Secret——防止敏感信息泄露)

聚合 ClusterRole

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: monitoring-view
  labels:
    rbac.authorization.k8s.io/aggregate-to-view: "true"  # 自动聚合到 view
rules:
- apiGroups: [monitoring.coreos.com]
  resources: [prometheuses, servicemonitors]
  verbs: [get, list, watch]

带 aggregate-to-* label 的 ClusterRole 会自动被聚合到对应的 ClusterRole 中。安装 Prometheus Operator 后,view ClusterRole 自动获得查看 Prometheus/ServiceMonitor 的权限——不需要手动修改 view。

真实场景:RBAC 权限排查

场景:开发者小王报告"我无法在 staging Namespace 中创建 Deployment"。

排查步骤:

# 1. 确认小王的身份
# 小王通过 OIDC 登录,用户名是 wang@example.com,组是 dev-team

# 2. 检查小王是否有权限
kubectl auth can-i create deployments --namespace staging --as wang@example.com
# no

# 3. 检查是通过用户还是组获得权限的
kubectl auth can-i create deployments --namespace staging \
  --as wang@example.com --as-group dev-team
# no

# 4. 列出 staging Namespace 中的所有 RoleBinding
kubectl get rolebindings -n staging -o wide
# NAME       ROLE                    SUBJECTS
# dev-view   ClusterRole/view        Group:dev-team

# 发现了——dev-team 只有 view 权限,没有 edit 或 admin 权限

# 5. 修复:创建 RoleBinding 授予 edit 权限
kubectl create rolebinding dev-edit --clusterrole=edit \
  --group=dev-team --namespace=staging

# 6. 验证
kubectl auth can-i create deployments --namespace staging \
  --as wang@example.com --as-group dev-team
# yes

关键命令:kubectl auth can-i 是 RBAC 排查的瑞士军刀。加 --list 可以列出所有权限:

kubectl auth can-i --list --namespace staging --as wang@example.com

5.3 Admission Control:在资源写入 etcd 前拦截

认证(你是谁)和授权(你能不能做)通过后,请求还要经过 Admission Control——一道最后的关卡,可以修改或拒绝资源。

Request → Authentication → Authorization → Mutating Admission → Schema Validation → Validating Admission → etcd

为什么需要 Admission? 授权只能回答"这个用户能不能创建 Pod"——但不能回答"这个 Pod 的 image 是不是来自我们信任的 Registry"或"这个 Pod 设没设 resource limits"。这些语义级别的策略需要 Admission Controller 来执行。

Mutating vs Validating

关键内置 Admission Controller:

Controller 做什么
LimitRanger 为未设置 requests/limits 的 Pod 注入默认值
ServiceAccount 为 Pod 注入 ServiceAccount Token
DefaultStorageClass 为未指定 StorageClass 的 PVC 设置默认值
ResourceQuota 检查是否超出 Namespace 配额
PodSecurity 检查 Pod Security Standards

Kyverno:用 YAML 写策略

OPA/Gatekeeper 使用 Rego 语言写策略——学习曲线陡峭。Kyverno 用 YAML 写策略,对 K8s 用户更友好:

apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata:
  name: require-labels
spec:
  validationFailureAction: Enforce
  rules:
  - name: check-for-labels
    match:
      resources:
        kinds: [Deployment]
    validate:
      message: "Deployment must have 'app' and 'team' labels."
      pattern:
        metadata:
          labels:
            app: "?*"
            team: "?*"

Kyverno 不仅能验证,还能变更(自动添加 label)和生成(创建 Deployment 时自动创建对应的 NetworkPolicy)。

5.4 Pod Security:限制 Pod 能做什么

为什么需要 Pod Security?

一个恶意或失误的 Pod 可以做很多危险的事:

Pod Security Standards:三个安全级别

级别 限制 适用场景
Privileged 无限制 系统组件(kube-proxy、CNI、CSI)
Baseline 禁止明显的提权(hostNetwork/hostPID/privileged) 大多数工作负载
Restricted 最严格(必须非 root、只读 rootfs、drop ALL capabilities) 安全敏感应用

Pod Security Admission(PSA)

通过 Namespace label 启用——不需要安装任何额外组件:

apiVersion: v1
kind: Namespace
metadata:
  name: production
  labels:
    pod-security.kubernetes.io/enforce: restricted    # 不合规就拒绝
    pod-security.kubernetes.io/audit: restricted       # 不合规记录到审计日志
    pod-security.kubernetes.io/warn: restricted        # 不合规向 kubectl 用户显示警告

推荐做法:先用 warn + audit 模式观察有多少 Pod 不合规,修复后再开启 enforce。

SecurityContext 关键配置

spec:
  securityContext:           # Pod 级别
    runAsNonRoot: true       # 不允许以 root 运行
    runAsUser: 1000          # 指定运行用户
    fsGroup: 2000            # Volume 的文件组
    seccompProfile:
      type: RuntimeDefault   # 启用系统调用过滤
  containers:
  - name: app
    securityContext:          # Container 级别
      allowPrivilegeEscalation: false    # 禁止提权
      readOnlyRootFilesystem: true       # 只读根文件系统
      capabilities:
        drop: [ALL]                       # 先丢掉所有 capability
        add: [NET_BIND_SERVICE]           # 只加需要的(绑定 <1024 端口)

5.5 NetworkPolicy:Pod 间的防火墙

默认情况下,K8s 中任何 Pod 可以和任何其他 Pod 通信——没有任何限制。这在安全上是不可接受的。

NetworkPolicy 让你定义 Pod 间的网络隔离规则:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: api-policy
  namespace: production
spec:
  podSelector:
    matchLabels:
      app: api               # 作用于带 app=api label 的 Pod
  policyTypes: [Ingress, Egress]

  ingress:                    # 入站规则
  - from:
    - namespaceSelector:      # 允许来自 frontend Namespace 的流量
        matchLabels:
          name: frontend
    - podSelector:            # 或同 Namespace 中 role=monitoring 的 Pod
        matchLabels:
          role: monitoring
    ports:
    - port: 8080
      protocol: TCP

  egress:                     # 出站规则
  - to:
    - podSelector:
        matchLabels:
          app: database       # 只允许访问 database Pod
    ports:
    - port: 5432
  - to:                       # 允许 DNS(不放行 DNS 的话域名解析都不通)
    - namespaceSelector: {}
    ports:
    - port: 53
      protocol: UDP
    - port: 53
      protocol: TCP

注意 from 中多个选择器的逻辑:

上面的例子中 namespaceSelector 和 podSelector 是两个独立的 - 列表项,所以是 OR 关系。如果把它们写在同一个列表项里就变成 AND("来自 frontend Namespace 中带 role=monitoring 的 Pod")。

强烈推荐在生产 Namespace 中启用默认拒绝策略:

# 默认拒绝所有入站——然后逐个 Pod 明确放行
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-ingress
spec:
  podSelector: {}          # 选择所有 Pod
  policyTypes: [Ingress]
  # ingress 留空 = 不允许任何入站

前提:NetworkPolicy 需要 CNI 支持。Flannel 不支持 NetworkPolicy——用 Flannel 的话,即使你创建了 NetworkPolicy,也不会生效。Calico 和 Cilium 都完整支持。

5.6 Secret 管理

K8s 原生 Secret 不够安全

K8s Secret 有一个常见的误解:很多人以为 Secret 是加密存储的。实际上:

# 创建一个 Secret
kubectl create secret generic db-password --from-literal=password=s3cr3t

# 查看——直接可见 Base64 编码(不是加密!)
kubectl get secret db-password -o jsonpath='{.data.password}' | base64 -d
# s3cr3t

Base64 只是编码,不是加密——任何人都能解码。Secret 的安全依赖于:

  1. RBAC:限制谁能读取 Secret
  2. etcd 加密:配置 EncryptionConfiguration,让 Secret 在 etcd 中加密存储
  3. 传输加密:apiserver 到 etcd 的通信使用 TLS

生产环境的 Secret 管理方案

External Secrets Operator——从外部密钥管理系统(Vault、AWS Secrets Manager 等)同步 Secret 到 K8s:

apiVersion: external-secrets.io/v1beta1
kind: ExternalSecret
metadata:
  name: database-credentials
spec:
  refreshInterval: 1h         # 每小时同步一次
  secretStoreRef:
    name: vault-backend
    kind: ClusterSecretStore
  target:
    name: database-credentials  # 同步到 K8s Secret
  data:
  - secretKey: password
    remoteRef:
      key: secret/data/production/database
      property: password

好处:Secret 的唯一真实来源(Single Source of Truth)在 Vault 中。K8s 中的 Secret 是自动同步的副本。轮换密码只需在 Vault 中操作。

Sealed Secrets——加密后的 Secret 可以安全地存储在 Git 仓库中(适合 GitOps):

# 加密 Secret(只有集群中的 Controller 能解密)
kubeseal --format=yaml < secret.yaml > sealed-secret.yaml
# sealed-secret.yaml 可以安全地提交到 Git

5.7 供应链安全

为什么需要关注?

如果攻击者往你使用的镜像中注入了恶意代码(如挖矿脚本),你的 Pod 会在不知情的情况下运行恶意软件。

防御措施:

  1. 镜像签名与验证——用 Cosign 签名镜像,用 Kyverno 在 Admission 阶段强制验证签名:
apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata:
  name: verify-image-signature
spec:
  validationFailureAction: Enforce
  rules:
  - name: check-signature
    match:
      resources:
        kinds: [Pod]
    verifyImages:
    - imageReferences: ["myregistry/*"]
      attestors:
      - entries:
        - keys:
            publicKeys: |-
              -----BEGIN PUBLIC KEY-----
              ...
              -----END PUBLIC KEY-----

没有签名的镜像直接被 Admission 拒绝——根本不会被调度。

  1. 镜像漏洞扫描:
# Trivy 扫描镜像漏洞
trivy image --severity HIGH,CRITICAL myregistry/myapp:v1.0
# 在 CI/CD 中设 --exit-code 1,有高危漏洞就阻断构建

Trivy Operator 可以在集群中持续扫描运行中的工作负载,发现新的 CVE 时自动生成 VulnerabilityReport。


6. 参考资料

资源 链接 说明
K8s 网络模型 kubernetes.io 网络基本原则
Service kubernetes.io Service 类型与机制
Ingress kubernetes.io Ingress 配置
Gateway API gateway-api.sigs.k8s.io 官方文档站
NetworkPolicy kubernetes.io 网络策略
Persistent Volumes kubernetes.io 存储体系
CSI Specification GitHub CSI 规范
RBAC kubernetes.io 权限管理
Pod Security Standards kubernetes.io 安全标准
Admission Controllers kubernetes.io 准入控制
K8s Networking 演讲 SpeakerDeck Tim Hockin — 网络核心开发者
深入理解 Cilium arthurchiao.art eBPF/Cilium 中文深度文章
K8s Network Packets Learnk8s 数据包完整路径
Calico docs.tigera.io 网络策略最佳实践
Cilium docs.cilium.io eBPF 网络方案
Istio istio.io Service Mesh
Rook-Ceph rook.io 分布式存储
Velero velero.io 备份与恢复
External Secrets Operator external-secrets.io 外部 Secret 管理
Kyverno kyverno.io 策略引擎
Trivy aquasecurity.github.io 漏洞扫描
Kubernetes in Action (2nd Ed) Marko Lukša 网络和存储讲解最详细
Networking and Kubernetes Strong & Lancey 专注 K8s 网络的深度书籍
Hacking Kubernetes Martin & Hausenblas K8s 安全攻防

本文基于 Kubernetes v1.30+ 版本撰写。