网络存储与安全体系深度解析
你的 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 个容器呢?
- 端口冲突:两个容器都想用 8080 怎么办?手动分配端口?
- 服务发现噩梦:每个容器的地址是
HostIP:Port,容器重启后端口可能变,所有引用都得更新 - NAT 带来的问题:容器看到的自己的 IP(如
172.17.0.2)和别人看到的它的 IP(HostA:8080)不一样——日志中的源 IP 没有意义,调试困难
K8s 做了一个大胆的决定:干掉 NAT,给每个 Pod 一个真实的 IP。
这就是 K8s 网络模型的三条铁律:
- Pod-to-Pod:任何 Pod 可以不经过 NAT 直接和任何其他 Pod 通信
- Node-to-Pod:任何 Node 可以不经过 NAT 直接和任何 Pod 通信
- IP 一致性:Pod 自己看到的 IP = 别人看到的它的 IP
IP-per-Pod:每个 Pod 有独立 IP,Pod 内的所有容器共享这个 IP(通过共享 Network Namespace)。这意味着:
- Pod 内容器通过
localhost互相通信——就像传统世界里同一台机器上的多个进程 - Pod 间通过 Pod IP 直接通信——就像局域网内的两台机器
- 不需要端口映射——每个 Pod 都可以随便用 80 端口,不会冲突
代价:这个美好的"扁平网络"在物理上并不存在——底层物理网络并不知道 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 额外支持多种负载均衡算法:
rr(Round Robin):轮询lc(Least Connections):最少连接sh(Source Hashing):源地址哈希——同一个客户端总是访问同一个后端(会话保持)
什么时候该从 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。问题:
- 多了一跳:数据包从 Node-1 转发到 Node-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 时:
- 单个 Endpoints 对象变得巨大(可能超过 1MB)
- 任何一个 Pod 变化(比如一个 Pod 重启)都触发整个 Endpoints 对象的更新
- 所有 Watch 该 Endpoints 的 kube-proxy 实例都收到全量推送——5000 个 endpoint 的完整列表
- 假设集群有 200 个 Node,每次 Pod 变化 = 200 × 全量 Endpoints 数据传输
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 带来巨大负载。
解决方案:
- 使用 FQDN(末尾加
.):api.example.com.——告诉解析器"这是绝对域名,不要拼接 search 域" - 降低 ndots:
ndots: 2适合大多数场景(大部分外部域名至少有 2 个点) - 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。
现实场景中你需要的是:
- 基于域名路由:
api.example.com→ API 服务,web.example.com→ 前端服务 - 基于路径路由:
/api/*→ API 服务,/*→ 前端服务 - TLS 终止:在入口统一管理证书,后端服务不用管 HTTPS
- 流量控制:限速、重写、重定向
每个 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 用了几年后,社区发现了它的硬伤:
-
功能全靠 annotation hack:流量分割?
nginx.ingress.kubernetes.io/canary-weight: "10"。限速?又一个 annotation。不同 Ingress Controller 的 annotation 完全不兼容——从 Nginx 换到 Traefik,所有 annotation 都得改。 -
只有一层抽象:谁能创建 Ingress?谁能配置 TLS?谁能定义路由?全混在一起。基础设施团队和应用开发者的关注点没有分离。
-
只支持 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
核心优势:
- 角色分离:GatewayClass / Gateway / Route 分别由不同角色管理,权限清晰
- 内置高级特性:流量分割、Header 匹配、请求重写——全部是标准 API 字段,不是 annotation
- 多协议支持:HTTPRoute / GRPCRoute / TCPRoute / TLSRoute
- 可移植性:标准化 API,不同实现(Istio/Envoy/Nginx)之间可迁移
3. Service Mesh
3.1 Service Mesh 解决什么问题?
当你有 50 个微服务互相调用时,每个服务都需要处理:
- 重试和超时:调用下游服务超时了怎么办?
- 熔断:下游服务挂了,不能让调用方也跟着被拖垮
- 加密:服务间通信要不要 mTLS?
- 可观测性:请求从 A → B → C → D,哪一步慢了?
- 流量控制:金丝雀发布时只让 10% 流量到新版本
如果每个服务自己实现这些,那每种语言(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关注点分离:
- 开发者只写 PVC——"我需要 10Gi 存储"
- 运维定义 StorageClass——"使用什么存储后端、什么性能等级"
- CSI Driver 负责和存储系统交互——创建卷、格式化、挂载、快照、扩容
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 小时,kubelet 自动轮换)
- 绑定到特定 Pod(Pod 删除后 Token 即失效)
- 绑定到特定 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
- Mutating Admission Webhook:可以修改资源。比如 Istio 注入 sidecar 容器——你提交一个普通 Pod,Mutating Webhook 自动在 Pod spec 里加上 Envoy sidecar 容器。
- Validating Admission Webhook:只能拒绝或放行,不能修改。比如检查"所有 Pod 必须设置 resource limits"——不合规就拒绝。
关键内置 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 可以做很多危险的事:
privileged: true:获得 Node 的完整权限——可以读写 Node 上所有文件、访问所有设备hostNetwork: true:使用 Node 的网络——可以监听 Node 上的所有网络流量hostPID: true:看到 Node 上所有进程——可以 kill 其他容器的进程- 以 root 运行:容器逃逸漏洞(如 CVE-2019-5736)可以让容器内的 root 获得 Node 的 root 权限
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 中多个选择器的逻辑:
- 同一个
- from:下的多个选择器是 AND 关系 - 不同的
- from:之间是 OR 关系
上面的例子中 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 的安全依赖于:
- RBAC:限制谁能读取 Secret
- etcd 加密:配置 EncryptionConfiguration,让 Secret 在 etcd 中加密存储
- 传输加密: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 会在不知情的情况下运行恶意软件。
防御措施:
- 镜像签名与验证——用 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 拒绝——根本不会被调度。
- 镜像漏洞扫描:
# 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+ 版本撰写。