kubelet gc 源码分析

代码 kubernetes 1.26.15
问题

混部机子批量节点NotReady（十几个，丫的庞大故障），报错为：

意思就是 rpc 超了，节点下有太多 PodSandBox，crictl ps -a 一看有1400多个。。。大量exited的容器没有被删掉，累积起来超过了rpc限制。
PodSandBox 泄漏，crictl pods 可以看到大量同名但是 pod id不同的sanbox，几个月了kubelet并不自动删除

1. crictl pods
2. crictl inspectp <pod id>
3. crictl ps -a | grep <pod-id>
4. crictl logs <container-id>

复制代码

kubelet通过cri和containerd举行交互。crictl也可以通过cri规范和containerd交互
crictl 是 CRI(规范) 兼容的容器运行时命令行接口，可以利用它来检查和调试 k8s node节点上的容器运行时和应用程序。

kubernetes 垃圾接纳（Garbage Collection）机制由kubelet完成，kubelet定期清算不再利用的容器和镜像，每分钟举行一次容器的GC，每五分钟举行一次镜像的GC

代码逻辑

1. 开始GC

pkg/kubelet/kubelet.go:1352，开始GC func (kl *Kubelet) StartGarbageCollection()
pkg/kubelet/kuberuntime/kuberuntime_gc.go:409

1. // GarbageCollect removes dead containers using the specified container gc policy.
2. // Note that gc policy is not applied to sandboxes. Sandboxes are only removed when they are
3. // not ready and containing no containers.
4. //
5. // GarbageCollect consists of the following steps:
6. // * gets evictable containers which are not active and created more than gcPolicy.MinAge ago.
7. // * removes oldest dead containers for each pod by enforcing gcPolicy.MaxPerPodContainer.
8. // * removes oldest dead containers by enforcing gcPolicy.MaxContainers.
9. // * gets evictable sandboxes which are not ready and contains no containers.
10. // * removes evictable sandboxes.
11. func (cgc *containerGC) GarbageCollect(ctx context.Context, gcPolicy kubecontainer.GCPolicy, allSourcesReady bool, evictNonDeletedPods bool) error {
12.         errors := []error{}
13.         // Remove evictable containers
14.         if err := cgc.evictContainers(ctx, gcPolicy, allSourcesReady, evictNonDeletedPods); err != nil {
15.                 errors = append(errors, err)
16.         }
18.         // Remove sandboxes with zero containers
19.         if err := cgc.evictSandboxes(ctx, evictNonDeletedPods); err != nil {
20.                 errors = append(errors, err)
21.         }
23.         // Remove pod sandbox log directory
24.         if err := cgc.evictPodLogsDirectories(ctx, allSourcesReady); err != nil {
25.                 errors = append(errors, err)
26.         }
27.         return utilerrors.NewAggregate(errors)
28. }

复制代码

2. 驱逐容器 evictContainers

• 获取 evictUnits  pkg/kubelet/kuberuntime/kuberuntime_gc.go:187
  列出所有容器，容器中状态为 ContainerState_CONTAINER_RUNNING 和 container.CreatedAt 小于 minAge 直接跳过。
  其余添加到 evictUnits
  

1. map[evictUnit][]containerGCInfo
3. // evictUnit is considered for eviction as units of (UID, container name) pair.  
4. type evictUnit struct {  
5.     // UID of the pod.  
6.     uid types.UID  
7.     // Name of the container in the pod.  
8.     name string  
9. }
11. // containerGCInfo is the internal information kept for containers being considered for GC.
12. type containerGCInfo struct {
13.         // The ID of the container.
14.         id string
15.         // The name of the container.
16.         name string
17.         // Creation time for the container.
18.         createTime time.Time
19.         // If true, the container is in unknown state. Garbage collector should try
20.         // to stop containers before removal.
21.         unknown bool
22. }

复制代码

• 删除容器逻辑
  

1. // evict all containers that are evictable
2. func (cgc *containerGC) evictContainers(ctx context.Context, gcPolicy kubecontainer.GCPolicy, allSourcesReady bool, evictNonDeletedPods bool) error {
3.         // Separate containers by evict units.
4.         evictUnits, err := cgc.evictableContainers(ctx, gcPolicy.MinAge)
5.         if err != nil {
6.                 return err
7.         }
9.         // Remove deleted pod containers if all sources are ready.
10.         // 如果pod已经不存在了，那么就删除其中的所有容器。
11.         if allSourcesReady {
12.                 for key, unit := range evictUnits {
13.                         if cgc.podStateProvider.ShouldPodContentBeRemoved(key.uid) || (evictNonDeletedPods && cgc.podStateProvider.ShouldPodRuntimeBeRemoved(key.uid)) {
14.                                 cgc.removeOldestN(ctx, unit, len(unit)) // Remove all.
15.                                 delete(evictUnits, key)
16.                         }
17.                 }
18.         }
20.         // Enforce max containers per evict unit.
21.         // 执行 GC 策略，保证每个 POD 最多只能保存 MaxPerPodContainer 个已经退出的容器
22.         if gcPolicy.MaxPerPodContainer >= 0 {
23.                 cgc.enforceMaxContainersPerEvictUnit(ctx, evictUnits, gcPolicy.MaxPerPodContainer)
24.         }
26.         // Enforce max total number of containers.
27.         // 执行 GC 策略，保证节点上最多有 MaxContainers 个已经退出的容器
28.         if gcPolicy.MaxContainers >= 0 && evictUnits.NumContainers() > gcPolicy.MaxContainers {
29.                 // Leave an equal number of containers per evict unit (min: 1).
30.                 numContainersPerEvictUnit := gcPolicy.MaxContainers / evictUnits.NumEvictUnits()
31.                 if numContainersPerEvictUnit < 1 {
32.                         numContainersPerEvictUnit = 1
33.                 }
34.                 cgc.enforceMaxContainersPerEvictUnit(ctx, evictUnits, numContainersPerEvictUnit)
36.                 // If we still need to evict, evict oldest first.
37.                 numContainers := evictUnits.NumContainers()
38.                 if numContainers > gcPolicy.MaxContainers {
39.                         flattened := make([]containerGCInfo, 0, numContainers)
40.                         for key := range evictUnits {
41.                                 flattened = append(flattened, evictUnits[key]...)
42.                         }
43.                         sort.Sort(byCreated(flattened))
45.                         cgc.removeOldestN(ctx, flattened, numContainers-gcPolicy.MaxContainers)
46.                 }
47.         }
48.         return nil
49. }

复制代码

• 移除该pod uid下的所有容器
  pkg/kubelet/kuberuntime/kuberuntime_gc.go:126
  

1. // removeOldestN removes the oldest toRemove containers and returns the resulting slice.
2. func (cgc *containerGC) removeOldestN(ctx context.Context, containers []containerGCInfo, toRemove int) []containerGCInfo {
3.         // Remove from oldest to newest (last to first).
4.         numToKeep := len(containers) - toRemove
5.         if numToKeep > 0 {
6.                 sort.Sort(byCreated(containers))
7.         }
8.         for i := len(containers) - 1; i >= numToKeep; i-- {
9.                 if containers[i].unknown {
10.                         // Containers in known state could be running, we should try
11.                         // to stop it before removal.
12.                         id := kubecontainer.ContainerID{
13.                                 Type: cgc.manager.runtimeName,
14.                                 ID:   containers[i].id,
15.                         }
16.                         message := "Container is in unknown state, try killing it before removal"
17.                         if err := cgc.manager.killContainer(ctx, nil, id, containers[i].name, message, reasonUnknown, nil); err != nil {
18.                                 klog.ErrorS(err, "Failed to stop container", "containerID", containers[i].id)
19.                                 continue
20.                         }
21.                 }
22.                 if err := cgc.manager.removeContainer(ctx, containers[i].id); err != nil {
23.                         klog.ErrorS(err, "Failed to remove container", "containerID", containers[i].id)
24.                 }
25.         }
27.         // Assume we removed the containers so that we're not too aggressive.
28.         return containers[:numToKeep]
29. }

复制代码

3. 驱逐sandbox evictSandboxes

pkg/kubelet/kuberuntime/kuberuntime_gc.go:276
移除所有可驱逐的沙箱。可驱逐的沙箱必须满意以下要求: 1.未处于停当状态2.不包含任何容器。3.属于不存在的 (即，已经移除的) pod，或者不是该pod的近来创建的沙箱。
缘故原由分析

如今现象是 crictl pods 可以看到大量同名但是 pod id不同的sanbox。  根据 3 点要求

• sanbox notReady 满意
  
• 不包容任何容器 不满意
  
• 不是该pod的近来创建的沙箱 满意
  

因此sandbox 删不掉的缘故原由是 sandbox下的容器未被删除
容器异常退出后，根据重启计谋 restartPolicy: Always pod 会不断重启，直到 超过时限失败。
Pod 的垃圾收集

https://kubernetes.io/zh-cn/docs/concepts/workloads/pods/pod-lifecycle/#pod-garbage-collection
对于已失败的 Pod 而言，对应的 API 对象仍然会保留在集群的 API 服务器上， 直到用户或者控制器进程显式地将其删除。
Pod 的垃圾收集器（PodGC）是控制平面的控制器，它会在 Pod 个数超出所设置的阈值 （根据 kube-controller-manager 的 terminated-pod-gc-threshold 设置 默认值：12500）时删除已终止的 Pod（阶段值为 Succeeded 或 Failed）。 这一行为会避免随着时间演进不断创建和终止 Pod 而引起的资源泄漏问题。
容器什么时候删除


上面是pod纬度，但是我们的现象是容器删不掉，所以并不是缘故原由，继承看代码
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。