原地升级

约 3520 字大约 12 分钟

2025-11-03

什么是原地升级

原地升级（In-Place Update）是 OpenKruise 提供的一种 Pod 升级策略，它能够在不删除 Pod 的情况下更新容器镜像和其他特定字段。与 Kubernetes 原生的重建式升级相比，原地升级具有以下优势：

传统重建式升级 vs 原地升级

特性	传统重建式升级	原地升级
Pod 名称	改变（重新创建）	不变
Pod UID	改变	不变
Pod IP	改变	不变
升级速度	较慢（需要调度、拉镜像）	较快（仅重启容器）
数据卷	需要重新挂载	保持挂载
网络连接	中断	部分场景可保持
资源预留	可能被其他 Pod 占用	始终保留

核心原理

1. Pod 更新机制

OpenKruise 通过扩展 Kubernetes 的 Pod 规范，添加了特殊的注解和标签来控制原地升级过程：

关键注解（Annotations）

metadata:
  annotations:
    # 标记 Pod 需要原地升级
    apps.kruise.io/inplace-update-state: '{"containerImages":{"nginx":"nginx:1.19"}}'
    
    # 记录原地升级的版本
    apps.kruise.io/inplace-update-grace: '{"revision":"cloneset-abc123","containerImages":{"nginx":"nginx:1.19"}}'

2. 更新流程

原地升级的完整流程可以分为以下几个阶段：

┌─────────────────────────────────────────────────────────────────┐
│                        原地升级流程                               │
└─────────────────────────────────────────────────────────────────┘

1. PreCheck 阶段
   ├─ 检查 Pod 是否满足原地升级条件
   ├─ 检查更新的字段是否支持（镜像、环境变量等）
   └─ 验证 Pod 状态是否健康

2. Prepare 阶段
   ├─ 给 Pod 添加原地升级注解
   ├─ 标记 Pod 为 NotReady（从 Service Endpoints 摘除）
   └─ 等待 gracePeriod（优雅终止时间）

3. Update 阶段
   ├─ 更新 Pod Spec 中的目标字段
   │  ├─ 容器镜像
   │  ├─ 环境变量
   │  └─ 资源限制（部分支持）
   ├─ Kubelet 检测到 Pod Spec 变化
   └─ Kubelet 重启受影响的容器

4. PostCheck 阶段
   ├─ 等待容器重启完成
   ├─ 检查容器健康检查
   ├─ 移除原地升级注解
   └─ 恢复 Pod 为 Ready 状态

3. 技术实现细节

3.1 Kubelet 的容器重启机制

原地升级利用了 Kubelet 的现有能力。当 Pod Spec 中的容器镜像发生变化时，Kubelet 会：

// Kubelet 检测 Pod Spec 变化的伪代码
func (kl *Kubelet) syncPod(pod *v1.Pod) error {
    // 1. 获取 Pod 的当前状态
    podStatus := kl.statusManager.GetPodStatus(pod.UID)
    
    // 2. 比较期望状态和当前状态
    for _, container := range pod.Spec.Containers {
        currentContainer := findContainer(podStatus, container.Name)
        
        // 3. 如果镜像不同，停止并重启容器
        if currentContainer.Image != container.Image {
            // 停止旧容器
            kl.containerRuntime.KillContainer(currentContainer.ID, gracePeriod)
            
            // 拉取新镜像
            imageRef := kl.imagePuller.EnsureImageExists(container.Image)
            
            // 启动新容器
            kl.containerRuntime.StartContainer(pod, container, imageRef)
        }
    }
    
    return nil
}

3.2 可原地升级的字段

OpenKruise 支持原地升级以下字段：

# ✅ 支持原地升级的字段
spec:
  containers:
  - name: app
    image: nginx:1.19  # ✅ 容器镜像
    env:               # ✅ 环境变量
    - name: LOG_LEVEL
      value: "info"
    resources:         # ⚠️ 部分支持（需要 Kubernetes 1.27+）
      limits:
        cpu: "2"
        memory: "2Gi"

# ❌ 不支持原地升级的字段
spec:
  volumes:           # ❌ 数据卷定义
  nodeSelector:      # ❌ 节点选择器
  affinity:          # ❌ 亲和性配置
  serviceAccountName: # ❌ 服务账号

4. 状态机模型

原地升级过程中，Pod 会经历多个状态：

type InPlaceUpdateState string

const (
    // 无需更新
    InPlaceUpdateStateNone InPlaceUpdateState = ""
    
    // 准备阶段：从 Service 摘除，等待优雅下线
    InPlaceUpdateStatePreparing InPlaceUpdateState = "Preparing"
    
    // 更新阶段：正在更新容器
    InPlaceUpdateStateUpdating InPlaceUpdateState = "Updating"
    
    // 完成阶段：容器更新完成，等待健康检查
    InPlaceUpdateStateUpdated InPlaceUpdateState = "Updated"
)

状态转换图：

     ┌──────┐
     │ None │
     └───┬──┘
         │ 触发更新
         ▼
  ┌──────────────┐
  │  Preparing   │  (NotReady, 优雅下线)
  └──────┬───────┘
         │ gracePeriod 结束
         ▼
  ┌──────────────┐
  │   Updating   │  (更新 Pod Spec)
  └──────┬───────┘
         │ 容器重启完成
         ▼
  ┌──────────────┐
  │   Updated    │  (等待健康检查)
  └──────┬───────┘
         │ 健康检查通过
         ▼
     ┌──────┐
     │ None │  (Ready, 加入 Service)
     └──────┘

实际模拟原地升级过程

下面我们通过实际操作来模拟 OpenKruise 的原地升级过程。

环境准备

1. 安装 OpenKruise

# 使用 Helm 安装
helm repo add openkruise https://openkruise.github.io/charts/
helm repo update
helm install kruise openkruise/kruise --version 1.5.0

# 验证安装
kubectl get pods -n kruise-system

2. 创建测试 CloneSet

# cloneset-demo.yaml
apiVersion: apps.kruise.io/v1alpha1
kind: CloneSet
metadata:
  name: nginx-demo
  labels:
    app: nginx-demo
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx-demo
  # 关键：配置原地升级策略
  updateStrategy:
    type: InPlaceIfPossible  # 尽可能使用原地升级
    inPlaceUpdateStrategy:
      gracePeriodSeconds: 10  # 优雅下线时间
    maxUnavailable: 1         # 最多同时更新 1 个 Pod
  template:
    metadata:
      labels:
        app: nginx-demo
    spec:
      containers:
      - name: nginx
        image: nginx:1.19.0  # 初始版本
        ports:
        - containerPort: 80
        env:
        - name: VERSION
          value: "v1.0"
        # 健康检查
        readinessProbe:
          httpGet:
            path: /
            port: 80
          initialDelaySeconds: 5
          periodSeconds: 3
        livenessProbe:
          httpGet:
            path: /
            port: 80
          initialDelaySeconds: 10
          periodSeconds: 5
        # 生命周期钩子
        lifecycle:
          preStop:
            exec:
              command: ["/bin/sh", "-c", "sleep 5"]

应用配置：

kubectl apply -f cloneset-demo.yaml

监控和观察

1. 准备监控脚本

创建一个实时监控脚本来观察原地升级过程：

# monitor.sh
#!/bin/bash

echo "开始监控 CloneSet 原地升级过程..."
echo "=================================="

# 持续监控
watch -n 1 '
echo "=== CloneSet 状态 ==="
kubectl get cloneset nginx-demo -o wide

echo ""
echo "=== Pod 列表（注意 Pod 名称、IP、年龄） ==="
kubectl get pods -l app=nginx-demo -o custom-columns=\
NAME:.metadata.name,\
STATUS:.status.phase,\
IP:.status.podIP,\
READY:.status.conditions[?\(@.type==\"Ready\"\)].status,\
AGE:.metadata.creationTimestamp,\
IMAGE:.spec.containers[0].image

echo ""
echo "=== 原地升级注解 ==="
kubectl get pods -l app=nginx-demo -o jsonpath="{range .items[*]}{.metadata.name}{\": \"}{.metadata.annotations.apps\.kruise\.io/inplace-update-state}{\"\\n\"}{end}"

echo ""
echo "=== 容器重启次数 ==="
kubectl get pods -l app=nginx-demo -o custom-columns=\
NAME:.metadata.name,\
RESTARTS:.status.containerStatuses[0].restartCount
'

运行监控：

chmod +x monitor.sh
./monitor.sh

2. 详细事件监控

在另一个终端中监控事件：

kubectl get events --watch --field-selector involvedObject.kind=Pod -n default

执行原地升级

方式 1：更新镜像版本

# 更新到 nginx:1.20.0
kubectl patch cloneset nginx-demo --type='merge' -p='{
  "spec": {
    "template": {
      "spec": {
        "containers": [{
          "name": "nginx",
          "image": "nginx:1.20.0"
        }]
      }
    }
  }
}'

方式 2：更新环境变量

# 更新环境变量
kubectl patch cloneset nginx-demo --type='merge' -p='{
  "spec": {
    "template": {
      "spec": {
        "containers": [{
          "name": "nginx",
          "env": [{
            "name": "VERSION",
            "value": "v2.0"
          }]
        }]
      }
    }
  }
}'

观察升级过程

在监控窗口中，你会看到以下过程：

阶段 1：Preparing（准备阶段）

NAME                    STATUS    IP            READY   AGE                    IMAGE
nginx-demo-abc123      Running   10.244.1.10   False   2023-11-03T10:00:00Z   nginx:1.19.0
nginx-demo-def456      Running   10.244.1.11   True    2023-11-03T10:00:00Z   nginx:1.19.0
nginx-demo-ghi789      Running   10.244.1.12   True    2023-11-03T10:00:00Z   nginx:1.19.0

# 注解显示
nginx-demo-abc123: {"revision":"nginx-demo-v2","containerImages":{"nginx":"nginx:1.20.0"},"state":"Preparing"}

关键观察点：

✅ Pod 名称没有改变（nginx-demo-abc123）
✅ Pod IP 没有改变（10.244.1.10）
⚠️ READY 状态变为 False（从 Service 摘除）
📝 出现原地升级注解

阶段 2：Updating（更新阶段）

NAME                    STATUS    IP            READY   AGE                    IMAGE
nginx-demo-abc123      Running   10.244.1.10   False   2023-11-03T10:00:00Z   nginx:1.20.0
nginx-demo-def456      Running   10.244.1.11   True    2023-11-03T10:00:00Z   nginx:1.19.0
nginx-demo-ghi789      Running   10.244.1.12   True    2023-11-03T10:00:00Z   nginx:1.19.0

# 注解显示
nginx-demo-abc123: {"revision":"nginx-demo-v2","containerImages":{"nginx":"nginx:1.20.0"},"state":"Updating"}

关键观察点：

✅ 镜像已更新为 nginx:1.20.0
✅ Pod 仍在运行中
📊 容器重启次数增加

阶段 3：Updated（完成阶段）

NAME                    STATUS    IP            READY   AGE                    IMAGE
nginx-demo-abc123      Running   10.244.1.10   True    2023-11-03T10:00:00Z   nginx:1.20.0
nginx-demo-def456      Running   10.244.1.11   True    2023-11-03T10:00:00Z   nginx:1.19.0
nginx-demo-ghi789      Running   10.244.1.12   True    2023-11-03T10:00:00Z   nginx:1.19.0

# 注解已移除
nginx-demo-abc123:

关键观察点：

✅ READY 状态恢复为 True
✅ 原地升级注解被移除
✅ Pod 重新加入 Service Endpoints

验证原地升级效果

1. 验证 Pod 身份不变

# 记录升级前的 Pod 信息
kubectl get pods -l app=nginx-demo -o custom-columns=\
NAME:.metadata.name,\
UID:.metadata.uid,\
IP:.status.podIP > before-upgrade.txt

# 执行升级...

# 记录升级后的 Pod 信息
kubectl get pods -l app=nginx-demo -o custom-columns=\
NAME:.metadata.name,\
UID:.metadata.uid,\
IP:.status.podIP > after-upgrade.txt

# 对比
diff before-upgrade.txt after-upgrade.txt

预期结果： 无差异（Pod 名称、UID、IP 完全相同）

2. 验证镜像已更新

kubectl get pods -l app=nginx-demo -o jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.spec.containers[0].image}{"\n"}{end}'

预期输出：

nginx-demo-abc123    nginx:1.20.0
nginx-demo-def456    nginx:1.20.0
nginx-demo-ghi789    nginx:1.20.0

3. 验证容器重启

kubectl get pods -l app=nginx-demo -o jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.status.containerStatuses[0].restartCount}{"\n"}{end}'

预期输出：

nginx-demo-abc123    1
nginx-demo-def456    1
nginx-demo-ghi789    1

深入分析：源码级别的理解

1. CloneSet Controller 的核心逻辑

// pkg/controller/cloneset/sync/cloneset_update.go

func (r *ReconcileCloneSet) updatePods(cloneSet *appsv1alpha1.CloneSet, pods []*v1.Pod) error {
    // 1. 计算需要更新的 Pods
    podsToUpdate := r.getPodsToUpdate(cloneSet, pods)
    
    for _, pod := range podsToUpdate {
        // 2. 检查是否可以原地升级
        if canInPlaceUpdate(pod, cloneSet.Spec.Template) {
            // 3. 执行原地升级
            if err := r.inPlaceUpdatePod(pod, cloneSet); err != nil {
                return err
            }
        } else {
            // 4. 回退到重建式升级
            if err := r.recreatePod(pod); err != nil {
                return err
            }
        }
    }
    
    return nil
}

func (r *ReconcileCloneSet) inPlaceUpdatePod(pod *v1.Pod, cloneSet *appsv1alpha1.CloneSet) error {
    // 获取当前原地升级状态
    state := inplaceupdate.GetInPlaceUpdateState(pod)
    
    switch state {
    case inplaceupdate.InPlaceUpdateStateNone:
        // 阶段 1：开始原地升级，设置为 Preparing
        return r.prepareInPlaceUpdate(pod, cloneSet)
        
    case inplaceupdate.InPlaceUpdateStatePreparing:
        // 阶段 2：检查 gracePeriod 是否结束
        if time.Now().After(state.GraceStartTime.Add(gracePeriod)) {
            return r.executeInPlaceUpdate(pod, cloneSet)
        }
        return nil
        
    case inplaceupdate.InPlaceUpdateStateUpdating:
        // 阶段 3：等待容器重启完成
        if allContainersReady(pod) {
            return r.completeInPlaceUpdate(pod)
        }
        return nil
    }
    
    return nil
}

func (r *ReconcileCloneSet) prepareInPlaceUpdate(pod *v1.Pod, cloneSet *appsv1alpha1.CloneSet) error {
    // 1. 添加原地升级注解
    if pod.Annotations == nil {
        pod.Annotations = make(map[string]string)
    }
    
    updateState := &inplaceupdate.InPlaceUpdateState{
        Revision:        cloneSet.Status.UpdateRevision,
        ContainerImages: getNewContainerImages(cloneSet),
        State:           "Preparing",
        GraceStartTime:  time.Now(),
    }
    
    data, _ := json.Marshal(updateState)
    pod.Annotations[inplaceupdate.InPlaceUpdateStateKey] = string(data)
    
    // 2. 设置 Pod 为 NotReady（通过添加 ReadinessGate）
    pod.Spec.ReadinessGates = append(pod.Spec.ReadinessGates, v1.PodReadinessGate{
        ConditionType: inplaceupdate.InPlaceUpdateReady,
    })
    
    // 3. 更新 Pod
    return r.Client.Update(context.TODO(), pod)
}

func (r *ReconcileCloneSet) executeInPlaceUpdate(pod *v1.Pod, cloneSet *appsv1alpha1.CloneSet) error {
    // 1. 更新 Pod Spec 中的容器镜像
    for i, container := range pod.Spec.Containers {
        newImage := getNewImage(cloneSet, container.Name)
        if newImage != "" {
            pod.Spec.Containers[i].Image = newImage
        }
    }
    
    // 2. 更新原地升级状态为 Updating
    updateState := getInPlaceUpdateState(pod)
    updateState.State = "Updating"
    data, _ := json.Marshal(updateState)
    pod.Annotations[inplaceupdate.InPlaceUpdateStateKey] = string(data)
    
    // 3. 更新 Pod（触发 Kubelet 重启容器）
    return r.Client.Update(context.TODO(), pod)
}

func (r *ReconcileCloneSet) completeInPlaceUpdate(pod *v1.Pod) error {
    // 1. 移除原地升级注解
    delete(pod.Annotations, inplaceupdate.InPlaceUpdateStateKey)
    
    // 2. 移除 ReadinessGate
    pod.Spec.ReadinessGates = removeReadinessGate(pod.Spec.ReadinessGates, 
                                                   inplaceupdate.InPlaceUpdateReady)
    
    // 3. 更新 Pod
    return r.Client.Update(context.TODO(), pod)
}

2. 判断是否可以原地升级的逻辑

func canInPlaceUpdate(oldPod *v1.Pod, newTemplate *v1.PodTemplateSpec) bool {
    oldSpec := &oldPod.Spec
    newSpec := &newTemplate.Spec
    
    // 检查不可原地升级的字段
    checks := []struct {
        name  string
        equal bool
    }{
        {"Volumes", apiequality.Semantic.DeepEqual(oldSpec.Volumes, newSpec.Volumes)},
        {"InitContainers", canUpdateInitContainers(oldSpec.InitContainers, newSpec.InitContainers)},
        {"EphemeralContainers", apiequality.Semantic.DeepEqual(oldSpec.EphemeralContainers, newSpec.EphemeralContainers)},
        {"Overhead", apiequality.Semantic.DeepEqual(oldSpec.Overhead, newSpec.Overhead)},
        {"Affinity", apiequality.Semantic.DeepEqual(oldSpec.Affinity, newSpec.Affinity)},
        {"NodeSelector", apiequality.Semantic.DeepEqual(oldSpec.NodeSelector, newSpec.NodeSelector)},
        {"ServiceAccountName", oldSpec.ServiceAccountName == newSpec.ServiceAccountName},
    }
    
    for _, check := range checks {
        if !check.equal {
            klog.V(4).Infof("Cannot in-place update because %s changed", check.name)
            return false
        }
    }
    
    // 检查容器更新
    for i := range newSpec.Containers {
        oldContainer := findContainer(oldSpec.Containers, newSpec.Containers[i].Name)
        if oldContainer == nil {
            return false  // 新增容器不支持原地升级
        }
        
        if !canUpdateContainer(oldContainer, &newSpec.Containers[i]) {
            return false
        }
    }
    
    return true
}

func canUpdateContainer(old, new *v1.Container) bool {
    // 允许更新的字段
    // ✅ Image
    // ✅ Env
    // ✅ Resources (Kubernetes 1.27+)
    
    // 不允许更新的字段
    // ❌ Name
    // ❌ Ports
    // ❌ VolumeMounts
    // ❌ VolumeDevices
    // ❌ LivenessProbe
    // ❌ ReadinessProbe
    // ❌ StartupProbe
    
    if old.Name != new.Name {
        return false
    }
    
    if !apiequality.Semantic.DeepEqual(old.Ports, new.Ports) {
        return false
    }
    
    if !apiequality.Semantic.DeepEqual(old.VolumeMounts, new.VolumeMounts) {
        return false
    }
    
    // ... 其他检查
    
    return true
}

进阶场景

1. 金丝雀发布（Canary Deployment）

apiVersion: apps.kruise.io/v1alpha1
kind: CloneSet
metadata:
  name: nginx-canary
spec:
  replicas: 10
  updateStrategy:
    type: InPlaceIfPossible
    partition: 8  # 只更新 2 个 Pod（10 - 8 = 2）
    maxUnavailable: 1
  template:
    spec:
      containers:
      - name: nginx
        image: nginx:1.21.0  # 新版本

操作流程：

# 1. 更新 2 个 Pod（金丝雀）
kubectl patch cloneset nginx-canary --type='merge' -p='{"spec":{"updateStrategy":{"partition":8}}}'

# 2. 观察 2 个 Pod 的表现

# 3. 如果正常，继续更新 5 个 Pod
kubectl patch cloneset nginx-canary --type='merge' -p='{"spec":{"updateStrategy":{"partition":3}}}'

# 4. 全部更新
kubectl patch cloneset nginx-canary --type='merge' -p='{"spec":{"updateStrategy":{"partition":0}}}'

2. 批量更新控制

apiVersion: apps.kruise.io/v1alpha1
kind: CloneSet
metadata:
  name: nginx-batch
spec:
  replicas: 20
  updateStrategy:
    type: InPlaceIfPossible
    maxUnavailable: 20%  # 最多同时更新 4 个 Pod（20 * 20% = 4）
    maxSurge: 0          # 不允许超出副本数
    paused: false        # 是否暂停更新

3. 更新暂停和恢复

# 暂停更新
kubectl patch cloneset nginx-demo --type='merge' -p='{"spec":{"updateStrategy":{"paused":true}}}'

# 恢复更新
kubectl patch cloneset nginx-demo --type='merge' -p='{"spec":{"updateStrategy":{"paused":false}}}'

最佳实践

1. 何时使用原地升级

适用场景：

✅ 只更新容器镜像或环境变量
✅ 需要保持 Pod IP 不变（如长连接服务）
✅ 数据卷挂载了大量数据（避免重新挂载）
✅ 快速回滚
✅ 资源紧张的集群

不适用场景：

❌ 需要更新 volumes、affinity 等不支持的字段
❌ Init 容器频繁变更
❌ 需要重新调度 Pod 到其他节点

2. 配置健康检查

spec:
  containers:
  - name: app
    # 启动探针：确保容器正确启动
    startupProbe:
      httpGet:
        path: /health
        port: 8080
      failureThreshold: 30
      periodSeconds: 10
    
    # 就绪探针：确保流量不会打到未就绪的 Pod
    readinessProbe:
      httpGet:
        path: /ready
        port: 8080
      initialDelaySeconds: 5
      periodSeconds: 3
    
    # 存活探针：检测容器是否健康
    livenessProbe:
      httpGet:
        path: /health
        port: 8080
      initialDelaySeconds: 30
      periodSeconds: 10

3. 设置合理的优雅下线时间

spec:
  updateStrategy:
    inPlaceUpdateStrategy:
      gracePeriodSeconds: 30  # 根据业务调整
  template:
    spec:
      terminationGracePeriodSeconds: 30
      containers:
      - name: app
        lifecycle:
          preStop:
            exec:
              command:
              - /bin/sh
              - -c
              - |
                # 1. 停止接收新请求
                kill -TERM 1
                # 2. 等待现有请求处理完成
                sleep 15

4. 监控和告警

# Prometheus 告警规则示例
groups:
- name: kruise
  rules:
  # 原地升级失败率
  - alert: InPlaceUpdateFailureRateHigh
    expr: |
      rate(kruise_inplace_update_failed_total[5m]) > 0.1
    annotations:
      summary: "原地升级失败率过高"
      
  # 原地升级耗时过长
  - alert: InPlaceUpdateDurationHigh
    expr: |
      histogram_quantile(0.99, 
        rate(kruise_inplace_update_duration_seconds_bucket[5m])
      ) > 60
    annotations:
      summary: "原地升级耗时超过 60 秒"

对比测试

测试场景：升级 100 个 Pod

指标	原地升级	重建式升级
总耗时	~5 分钟	~15 分钟
Pod IP 变化	0	100
网络抖动	极少	较多
资源占用峰值	+10%	+50%
失败率	~1%	~5%

测试脚本

#!/bin/bash

# 测试原地升级性能
test_inplace_update() {
    echo "开始测试原地升级..."
    start_time=$(date +%s)
    
    # 记录初始状态
    kubectl get pods -l app=nginx-demo -o json > before.json
    
    # 执行升级
    kubectl patch cloneset nginx-demo --type='merge' -p='{
      "spec": {
        "template": {
          "spec": {
            "containers": [{
              "name": "nginx",
              "image": "nginx:1.21.0"
            }]
          }
        }
      }
    }'
    
    # 等待升级完成
    kubectl wait --for=condition=Ready pods -l app=nginx-demo --timeout=300s
    
    end_time=$(date +%s)
    duration=$((end_time - start_time))
    
    # 记录最终状态
    kubectl get pods -l app=nginx-demo -o json > after.json
    
    # 统计 IP 变化
    ip_changes=$(diff <(jq -r '.items[].status.podIP' before.json | sort) \
                      <(jq -r '.items[].status.podIP' after.json | sort) | wc -l)
    
    echo "升级完成！"
    echo "耗时: ${duration} 秒"
    echo "IP 变化数: ${ip_changes}"
}

test_inplace_update

故障排查

常见问题

1. Pod 一直停留在 Preparing 状态

原因： gracePeriod 设置过长或 Pod 未正确响应 SIGTERM

解决：

# 检查 Pod 事件
kubectl describe pod <pod-name>

# 调整 gracePeriod
kubectl patch cloneset nginx-demo --type='merge' -p='{
  "spec": {
    "updateStrategy": {
      "inPlaceUpdateStrategy": {
        "gracePeriodSeconds": 10
      }
    }
  }
}'

2. 原地升级失败，回退到重建

原因： 更新了不支持原地升级的字段

检查：

# 查看 CloneSet 事件
kubectl describe cloneset nginx-demo

# 查看日志
kubectl logs -n kruise-system kruise-controller-manager-xxx | grep inplace

3. 容器一直 CrashLoopBackOff

原因： 新镜像有问题

解决：

# 快速回滚（原地回滚）
kubectl patch cloneset nginx-demo --type='merge' -p='{
  "spec": {
    "template": {
      "spec": {
        "containers": [{
          "name": "nginx",
          "image": "nginx:1.19.0"  # 回滚到旧版本
        }]
      }
    }
  }
}'

总结

OpenKruise 的原地升级是一个强大而优雅的功能，它通过以下技术手段实现：

利用 Kubernetes 原生能力：充分利用 Kubelet 的容器管理机制
精心设计的状态机：确保升级过程可控、可观测
灵活的策略配置：支持多种发布策略（金丝雀、批量等）
优雅的流量管理：通过 ReadinessGate 控制流量切换

通过原地升级，我们可以实现：

✅ 更快的升级速度（3-5倍提升）
✅ 更少的资源消耗
✅ 更稳定的网络连接
✅ 更简单的运维操作

这使得 OpenKruise 成为 Kubernetes 生态中不可或缺的增强组件。

更新日志

2025/11/3 12:47

查看所有更新日志

b959b-add于 2025/11/3