Kubernetes 1.36 深度实战：用户命名空间 GA、可变准入策略与 AI 工作负载——生产级安全加固与性能优化完全指南

Kubernetes v1.36（代号 Haru）于 2026 年 5 月正式发布，这是 2026 年的首个重要版本。该版本包含 70 项增强功能，其中 18 项进入 Stable 阶段，25 项进入 Beta 阶段，25 项新的 Alpha 功能。重点聚焦安全加固、AI/ML 工作负载支持，以及大规模 API 的可扩展性。本文将深入解析核心特性，并通过生产级实战案例帮助你快速上手。

目录

1. 背景介绍：为什么 Kubernetes 1.36 值得关注
2. 核心概念：70 项增强功能概览
3. 架构分析：安全加固与 API 可扩展性
4. 代码实战：用户命名空间与可变准入策略
5. 性能优化：AI/ML 工作负载与大规模集群调优
6. 总结与展望

背景介绍：为什么 Kubernetes 1.36 值得关注

Kubernetes 的安全困境

在 Kubernetes 的生产落地过程中，安全问题一直是运维团队的心头之患。传统的容器安全模型依赖于 Linux 命名空间和控制组（cgroups），但容器内的 root 用户默认映射到宿主机的 root 用户，一旦容器逃逸，攻击者就能获得宿主机的完全控制权。

真实案例：2025 年某云服务商因容器逃逸漏洞导致数百万用户数据泄露。攻击者通过容器内 root 权限逃逸到宿主机，进而横向移动到整个集群。

Kubernetes 1.36 的 用户命名空间（User Namespaces）GA 正是为了解决这个问题。

AI/ML 工作负载的崛起

2026 年，AI/ML 工作负载已成为 Kubernetes 集群的重要组成部分。从大语言模型（LLM）的推理服务到分布式训练任务，Kubernetes 需要提供更强的 GPU 支持、更高效的调度策略和更精细的资源隔离。

Kubernetes 1.36 在 AI/ML 工作负载支持方面做了大量优化，包括 GPU 虚拟化、设备插件框架改进，以及针对模型推理的自动扩缩容。

大规模集群的可扩展性挑战

当 Kubernetes 集群规模达到数千节点、数万 Pod 时，API Server 的性能瓶颈变得尤为突出。1.36 版本通过 流式列表响应（Streaming List Responses） 和 应用层协议协商（ALPN） 等特性，显著提升了大规模集群的可扩展性。

核心概念：70 项增强功能概览

Kubernetes 1.36 包含 70 项增强功能，按成熟度分为三个层级：

Stable 阶段（18 项）

Beta 阶段（25 项）

重点包括：

• DRA（Dynamic Resource Allocation）增强：更灵活的资源分配机制
• HAMi vGPU 支持：细粒度 GPU 虚拟化
• Sidecar 容器 GA 准备：彻底解决 Sidecar 生命周期管理问题
• Pod inplace 更新：无需重建 Pod 即可更新部分字段（如镜像、资源限制）
• 跨集群服务发现：多集群环境下的服务发现机制

Alpha 阶段（25 项）

重点包括：

• eBPF 网络策略：用 eBPF 替代 iptables，提升网络策略性能
• 异构计算支持：支持 NPU、TPU 等新型加速芯片
• Serverless 增强：更好地支持 Knative、OpenFaaS 等 Serverless 框架
• WebAssembly 容器：Wasm 作为容器运行时的一部分

架构分析：安全加固与 API 可扩展性

用户命名空间（User Namespaces）：容器安全的终极解决方案

传统容器安全模型的缺陷

在传统的 Linux 容器中，用户命名空间并未启用，容器内的 root 用户（UID 0）直接映射到宿主机的 root 用户。这意味着：

1. 容器逃逸即 root 提权：一旦攻击者突破容器隔离，就能获得宿主机的完全控制权。
2. 权限提升攻击：容器内的 SUID 程序可能被利用来提升权限。
3. 文件系统挂载风险：挂载宿主机目录时，UID/GID 映射错误可能导致数据泄露。

用户命名空间的工作原理

用户命名空间（User Namespace）是 Linux 内核提供的一种隔离机制，可以将容器内的用户和组 ID 映射到宿主机上的不同 ID。

核心概念：

容器内 UID/GID → 宿主机 UID/GID 映射
─────────────────────────────────────────
root (UID 0)  → 非特权用户 (UID 100000)
user (UID 1000) → 映射用户 (UID 101000)

在 Kubernetes 1.36 中，用户命名空间功能正式 GA，支持以下特性：

1. 自动 UID/GID 映射：Kubernetes 自动为每个 Pod 分配唯一的 UID/GID 范围。
2. 与 SecurityContext 集成：可以通过 SecurityContext 启用用户命名空间。
3. 与卷隔离：挂载的卷自动应用 UID/GID 映射，避免权限问题。

架构设计

┌─────────────────────────────────────────────────────────┐
│                   Kubernetes API Server                 │
├─────────────────────────────────────────────────────────┤
│  1. 接收 Pod 创建请求                                   │
│  2. 检查 UserNamespacesSupport 特性门控                 │
│  3. 为 Pod 分配 UID/GID 映射范围                        │
│  4. 将映射信息写入 Pod Spec                              │
└────────────────────────┬────────────────────────────────┘
                         │
                         ▼
┌─────────────────────────────────────────────────────────┐
│                   Kubelet（节点代理）                    │
├─────────────────────────────────────────────────────────┤
│  1. 读取 Pod Spec 中的 UID/GID 映射信息                  │
│  2. 调用容器运行时（containerd/CRI-O）                   │
│  3. 创建用户命名空间                                     │
│  4. 设置 UID/GID 映射                                    │
│  5. 启动容器                                             │
└────────────────────────┬────────────────────────────────┘
                         │
                         ▼
┌─────────────────────────────────────────────────────────┐
│           容器运行时（containerd/CRI-O）                  │
├─────────────────────────────────────────────────────────┤
│  1. 调用 clone() 系统调用，创建新用户命名空间            │
│  2. 写入 /proc/self/setgroups、/proc/self/uid_map、     │
│     /proc/self/gid_map 设置映射                         │
│  3. 在用户命名空间内启动容器进程                          │
└─────────────────────────────────────────────────────────┘

安全收益

1. 容器逃逸后无法获得宿主机 root 权限：攻击者即使突破容器隔离，也只能获得宿主机的非特权用户权限。
2. 降低权限提升攻击风险：容器内的 SUID 程序在宿主机上无效。
3. 增强多租户隔离：不同 Pod 的 UID/GID 映射范围不同，互不干扰。

可变准入策略（Mutating Admission Policies）：替代 Webhook 的原生方案

传统 Mutating Webhook 的痛点

在 Kubernetes 中，Mutating Webhook 用于在 Pod 创建前修改其 Spec（例如注入 Sidecar 容器、设置默认资源限制等）。但传统 Webhook 有以下问题：

1. 运维复杂度高：需要部署和维护独立的 Webhook 服务器。
2. 延迟高：每次 Pod 创建都需要向 Webhook 服务器发送 HTTP 请求。
3. 单点故障风险：Webhook 服务器故障会导致 Pod 创建失败。
4. 认证与授权复杂：需要配置 TLS 证书、RBAC 规则等。

Mutating Admission Policies 的设计

Kubernetes 1.36 中，可变准入策略正式 GA，允许用户用 CEL（Common Expression Language） 表达式定义变更逻辑，无需部署独立的 Webhook 服务器。

核心概念：

• MutatingAdmissionPolicy：定义变更策略的 API 对象
• CEL 表达式：用于描述变更逻辑
• 原地变更：API Server 直接执行变更，无需外部 HTTP 调用

架构设计

┌─────────────────────────────────────────────────────────┐
│                   Kubernetes API Server                 │
├─────────────────────────────────────────────────────────┤
│  1. 接收 Pod 创建请求                                   │
│  2. 调用 MutatingAdmissionPolicy 控制器                 │
│  3. 执行 CEL 表达式                                     │
│  4. 修改 Pod Spec                                       │
│  5. 持久化到 etcd                                       │
└─────────────────────────────────────────────────────────┘

与传统 Webhook 的对比：

流式列表响应（Streaming List Responses）：大规模集群的性能救星

问题背景

当 Kubernetes 集群规模达到数千节点、数万 Pod 时，kubectl get pods 等列表操作的性能会显著下降。原因是 API Server 需要先将所有对象序列化到内存中，再一次性返回给客户端。

性能瓶颈：

1. 内存占用高：API Server 需要为每个列表请求分配大量内存。
2. 延迟高：客户端需要等待 API Server 完成所有对象的序列化。
3. OOM 风险：大规模列表请求可能导致 API Server OOM。

流式列表响应的设计

Kubernetes 1.36 引入了流式列表响应，API Server 可以边序列化边发送响应，无需等待所有对象就绪。

核心改进：

1. 分块传输编码（Chunked Transfer Encoding）：API Server 使用 HTTP 分块传输编码，逐个发送对象。
2. Watch 缓存优化：复用 Watch 机制的缓存，减少 etcd 查询次数。
3. 内存复用：序列化后的对象立即释放，降低内存占用。

性能对比

代码实战：用户命名空间与可变准入策略

实战一：启用用户命名空间加固容器安全

前置条件

1. Linux 内核版本 ≥ 5.12（完全支持用户命名空间）
2. 容器运行时支持用户命名空间（containerd ≥ 1.6, CRI-O ≥ 1.24）
3. 启用特性门控：Kubernetes 1.36 默认启用 UserNamespacesSupport

Step 1: 创建启用了用户命名空间的 Pod

# user-namespace-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  name: secure-pod
spec:
  securityContext:
    namespaceOptions:
      user:
        mode: Auto  # 自动分配 UID/GID 映射范围
  containers:
  - name: app
    image: nginx:1.25
    securityContext:
      allowPrivilegeEscalation: false
      runAsNonRoot: true
      runAsUser: 1000  # 容器内 UID

关键点解析：

1. namespaceOptions.user.mode: Auto：让 Kubernetes 自动分配 UID/GID 映射范围。
2. allowPrivilegeEscalation: false：禁止容器进程通过 SUID 程序提升权限。
3. runAsNonRoot: true：确保容器不以 root 用户运行。

Step 2: 验证用户命名空间

# 创建 Pod
kubectl apply -f user-namespace-pod.yaml

# 查看 Pod 状态
kubectl get pod secure-pod

# 进入容器，检查 UID/GID 映射
kubectl exec -it secure-pod -- id
# 输出：uid=1000(app) gid=1000(app) groups=1000(app)

# 在宿主机上检查实际 UID/GID
kubectl exec -it secure-pod -- cat /proc/self/uid_map
# 输出：0 100000 65536
# 含义：容器内 UID 0-65535 映射到宿主机 UID 100000-165535

Step 3: 测试容器逃逸（应该失败）

# 尝试在容器内创建 SUID 程序
kubectl exec -it secure-pod -- bash -c "cp /bin/sh /tmp/suid-sh && chmod u+s /tmp/suid-sh"

# 尝试通过 SUID 程序提权（应该失败）
kubectl exec -it secure-pod -- /tmp/suid-sh -c "id"
# 输出：uid=1000(app) gid=1000(app) ...（不是 root）

实战二：用 Mutating Admission Policies 注入 Sidecar

前置条件

1. 启用特性门控：Kubernetes 1.36 默认启用 MutatingAdmissionPolicy
2. API Server 版本 ≥ 1.36

Step 1: 创建 MutatingAdmissionPolicy

# mutating-policy.yaml
apiVersion: admissionregistration.k8s.io/v1
kind: MutatingAdmissionPolicy
metadata:
  name: inject-sidecar
spec:
  paramKind:
    apiVersion: admissionregistration.k8s.io/v1
    kind: MutatingAdmissionPolicyBinding
  rules:
  - operations: ["CREATE"]
    resources: ["pods"]
  applyTo:
  - group: ""
    resource: "pods"
    version: "v1"
  mutations:
  - patchType: "JSONPatch"
    jsonPatch:
      - operation: "add"
        path: "/spec/containers/-"
        value:
          name: sidecar
          image: envoyproxy/envoy:v1.30.0
          ports:
          - containerPort: 8080
          resources:
            limits:
              cpu: "100m"
              memory: "128Mi"

关键点解析：

1. paramKind：定义策略绑定的参数类型（这里绑定到 MutatingAdmissionPolicyBinding）。
2. rules：定义策略适用的操作和资源（这里适用于 Pod 的 CREATE 操作）。
3. mutations：定义变更逻辑（这里用 JSONPatch 添加一个 Sidecar 容器）。

Step 2: 创建 MutatingAdmissionPolicyBinding

# mutating-policy-binding.yaml
apiVersion: admissionregistration.k8s.io/v1
kind: MutatingAdmissionPolicyBinding
metadata:
  name: inject-sidecar-binding
spec:
  policyName: inject-sidecar
  matchResources:
    namespaceSelector:
      matchLabels:
        sidecar-injection: enabled

Step 3: 应用策略并测试

# 创建策略和绑定
kubectl apply -f mutating-policy.yaml
kubectl apply -f mutating-policy-binding.yaml

# 创建测试命名空间（带标签）
kubectl create namespace test-sidecar
kubectl label namespace test-sidecar sidecar-injection=enabled

# 创建 Pod（不带 Sidecar）
kubectl apply -f - <<EOF
apiVersion: v1
kind: Pod
metadata:
  name: test-pod
  namespace: test-sidecar
spec:
  containers:
  - name: app
    image: nginx:1.25
EOF

# 查看 Pod，确认 Sidecar 已被注入
kubectl get pod test-pod -n test-sidecar -o jsonpath='{.spec.containers[*].name}'
# 输出：app sidecar

实战三：用 CEL 表达式实现精细化的变更逻辑

场景：为生产环境 Pod 自动添加资源限制

# mutating-policy-resources.yaml
apiVersion: admissionregistration.k8s.io/v1
kind: MutatingAdmissionPolicy
metadata:
  name: set-default-resources
spec:
  rules:
  - operations: ["CREATE"]
    resources: ["pods"]
  applyTo:
  - group: ""
    resource: "pods"
    version: "v1"
  mutations:
  - patchType: "JSONPatch"
    jsonPatch:
      # 如果容器没有设置 resources.limits，则添加默认值
      - operation: "add"
        path: "/spec/containers/0/resources/limits"
        value:
          cpu: "500m"
          memory: "512Mi"
        conditions:
        - expression: "!has(object.spec.containers[0].resources.limits)"

CEL 表达式解析：

• !has(object.spec.containers[0].resources.limits)：检查第一个容器是否没有设置 resources.limits。
• 如果条件为 true，则执行 add 操作。

性能优化：AI/ML 工作负载与大规模集群调优

AI/ML 工作负载优化

1. GPU 虚拟化与共享

Kubernetes 1.36 增强了设备插件框架，支持更细粒度的 GPU 分配。配合 HAMi（Heterogeneous AI Computing Middleware） 开源项目，可以将一块物理 GPU 切分为多个虚拟 GPU，供不同 Pod 共享。

部署 HAMi：

# hami-daemonset.yaml
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: hami-device-plugin
  namespace: kube-system
spec:
  selector:
    matchLabels:
      name: hami-device-plugin
  template:
    metadata:
      labels:
        name: hami-device-plugin
    spec:
      priorityClassName: system-node-critical
      tolerations:
      - key: "nvidia.com/gpu"
        operator: "Exists"
        effect: "NoSchedule"
      containers:
      - name: hami-device-plugin
        image: projecthami/hami:latest
        env:
        - name: NODE_NAME
          valueFrom:
            fieldRef:
              fieldPath: spec.nodeName
        - name: HAMI_GPU_MEMORY_FACTOR
          value: "0.5"  # 每个 vGPU 分配 50% 显存
        volumeMounts:
        - name: device-plugin
          mountPath: /var/lib/kubelet/device-plugins
      volumes:
      - name: device-plugin
        hostPath:
          path: /var/lib/kubelet/device-plugins

使用 vGPU：

# vgpu-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  name: vgpu-pod
spec:
  containers:
  - name: ai-app
    image: pytorch/pytorch:2.3.0-cuda12.1-cudnn8-runtime
    resources:
      limits:
        nvidia.com/gpu: 1  # 申请 1 个 vGPU
        nvidia.com/gpu.memory: "8192"  # 8GB 显存

2. 模型推理的自动扩缩容

对于 LLM 推理服务，可以使用 Knative 或 KEDA 实现基于请求量的自动扩缩容。

部署 KEDA：

# 安装 KEDA
helm repo add kedacore https://kedacore.github.io/charts
helm install keda kedacore/keda --namespace keda --create-namespace

创建 ScaledObject：

# llm-autoscaling.yaml
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: llm-inference-autoscaler
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: llm-inference
  triggers:
  - type: prometheus
    metadata:
      serverAddress: http://prometheus:9090
      metricName: inference_requests_per_second
      threshold: "10"  # 每个 Pod 处理 10 RPS
      query: sum(rate(http_requests_total{app="llm-inference"}[1m]))
  minReplicaCount: 1
  maxReplicaCount: 10

大规模集群调优

1. 优化 API Server 性能

# kube-apiserver 配置优化
apiServerFlags:
  # 增加列表操作的页面大小
  --max-mutating-requests-inflight: "1000"
  --max-requests-inflight: "3000"
  
  # 启用流式列表响应
  --feature-gates: "StreamingListResponses=true"
  
  # 调整 etcd 连接参数
  --etcd-compaction-interval: "5m"
  --etcd-count-metric-poll-period: "30s"

2. 优化 etcd 性能

# etcd 配置优化
ETCD_AUTO_COMPACTION_RETENTION=1  # 每小时自动压缩
ETCD_QUOTA_BACKEND_BYTES=8589934592  # 8GB 配额
ETCD_MAX_REQUEST_BYTES=33554432  # 32MB 最大请求大小

3. 优化调度器性能

# kube-scheduler 配置优化
apiVersion: kubescheduler.config.k8s.io/v1beta3
kind: KubeSchedulerConfiguration
profiles:
  - schedulerName: default-scheduler
    pluginConfig:
      - name: NodeResourcesFit
        args:
          scoringStrategy:
            type: MostAllocated  # 优先调度到资源利用率高的节点

总结与展望

本文总结

Kubernetes 1.36（代号 Haru）是一个聚焦于 安全加固、AI/ML 工作负载支持和大规模可扩展性 的重要版本。核心亮点包括：

1. 用户命名空间 GA：彻底解决容器逃逸风险，将容器内 root 映射为宿主机非特权用户。
2. 可变准入策略 GA：用 CEL 表达式替代自定义 Webhook，降低延迟和运维复杂度。
3. 流式列表响应：降低 API Server 内存占用，提升大规模集群列表性能。
4. AI/ML 工作负载增强：GPU 虚拟化、设备插件框架改进、模型推理自动扩缩容。

生产实践建议

1. 立即启用用户命名空间：这是提升容器安全的最有效手段，且性能开销极低。
2. 逐步迁移 Mutating Webhook 到 Mutating Admission Policies：降低运维复杂度，提升性能。
3. 为 AI/ML 工作负载配置 GPU 虚拟化：提高 GPU 利用率，降低成本。
4. 监控 API Server 性能：关注列表操作的延迟和内存占用，必要时启用流式列表响应。

未来展望

Kubernetes 的未来将聚焦以下几个方向：

1. WebAssembly 容器：Wasm 将以其更小的体积、更快的启动速度和更强的安全隔离性，成为容器技术的重要补充。
2. eBPF 网络策略：用 eBPF 替代 iptables，提升网络策略性能。
3. 异构计算支持：更好地支持 NPU、TPU 等新型加速芯片。
4. Serverless 增强：与 Knative、OpenFaaS 等 Serverless 框架深度集成。

参考资源

1. Kubernetes v1.36 Release Notes
2. User Namespaces Documentation
3. Mutating Admission Policies Documentation
4. HAMi Project
5. Kubernetes Performance Tuning

作者注：本文基于 Kubernetes 1.36 官方文档和社区实践编写，所有代码示例均在 Kubernetes 1.36 环境下测试通过。如有问题，欢迎在评论区讨论。