kubernetes 水平自动伸缩学习笔记(三)

目录


前言

前两篇笔记介绍了水平自动伸缩的设计及采集器的源码实现,本篇笔记继续介绍 hpa 控制器的实现逻辑。

设计

相比于 kubernetes 水平自动伸缩学习笔记(一) 中的控制器设计,kubernetes 的控制器设计有以下设计要点:

  • 控制器的同步周期不是通过定时器来做的,而是通过调谐器的优先级队列来实现的,把定时同步指标的功能下放到优先级队列,复用优先级队列的能力,妙妙妙。
  • 抽象出 autoscaling CRD 用于描述水平自动伸缩资源和指标的关系,控制器通过 List&Watch autoscaling CR 来确定对哪些资源做水平自动伸缩,通过 CRD 解耦用户和控制器。
  • 通过内存中的环形队列声明水平伸缩资源的时间窗口,做防抖动设计。
  • 高可用采用一主多从实现,水平伸缩决策由主控制器决定。
  • 支持 Kubernetes 自带 Metrics API,还支持 自定义 Metrics API 和 外部 Metrics API 等多种指标采集 API,可扩展性强。
  • 实现一套基于指标和当前副本数的 水平自动伸缩算法,灵活适用于多场景。
  • 支持快扩慢缩,对于多指标取每个指标最大值作为期望伸缩副本。

控制器的交互逻辑并不复杂,难点在于要考虑的情况多,对算法的设计要求比较高,比如容忍窗口防抖动、指标缺失自动推断、伸缩窗口、多指标适配、各种自定义行为等等都要兼顾。

源码

本源码基于 kubernetes release-1.20 解读

注册控制器

在 注册hpa控制器 中注册 hpa 控制器到 controllers 控制器集合中:

go 复制代码
func NewControllerInitializers(loopMode ControllerLoopMode) map[string]InitFunc {  
    controllers := map[string]InitFunc{}
    ...
    controllers["horizontalpodautoscaling"] = startHPAController
    ...
    return controllers
}

并发运行控制器:

go 复制代码
func StartControllers(ctx ControllerContext, startSATokenController InitFunc, controllers map[string]InitFunc, unsecuredMux *mux.PathRecorderMux) error {
	...
	for controllerName, initFn := range controllers {
		...
		debugHandler, started, err := initFn(ctx)
		...
	}
	...
}

调谐

hpa 控制器把周期获取指标的逻辑下放给 优先级队列和 informer,通过定义 resyncPeriod 来周期性获取指标:

go 复制代码
func CreateControllerContext(s *config.CompletedConfig, rootClientBuilder, clientBuilder clientbuilder.ControllerClientBuilder, stop <-chan struct{}) (ControllerContext, error) {
	...
	ctx := ControllerContext{  
       ClientBuilder:                   clientBuilder,  
       InformerFactory:                 sharedInformers,  
       ObjectOrMetadataInformerFactory: informerfactory.NewInformerFactory(sharedInformers, metadataInformers),  
       ComponentConfig:                 s.ComponentConfig,  
       RESTMapper:                      restMapper,  
       AvailableResources:              availableResources,  
       Cloud:                           cloud,  
       LoopMode:                        loopMode,  
       Stop:                            stop,  
       InformersStarted:                make(chan struct{}),  
       // 这里定义同步周期
       ResyncPeriod:                    ResyncPeriod(s),  
    }  
    return ctx, nil  
}

func ResyncPeriod(c *config.CompletedConfig) func() time.Duration {  
    return func() time.Duration {  
       factor := rand.Float64() + 1  
       return time.Duration(float64(c.ComponentConfig.Generic.MinResyncPeriod.Nanoseconds()) * factor)  
    }  
}

在调谐逻辑中计算期望的水平伸缩副本:

go 复制代码
func (a *HorizontalController) reconcileKey(key string) (deleted bool, err error) {  
    namespace, name, err := cache.SplitMetaNamespaceKey(key)  
    if err != nil {  
       return true, err  
    }  
  
	// 获取 autoscaling CR 资源
    hpa, err := a.hpaLister.HorizontalPodAutoscalers(namespace).Get(name)  
    if errors.IsNotFound(err) {  
       ...
    }  
    if err != nil {  
       return false, err  
    }  
  
	// 调谐 autoscaling CR
    return false, a.reconcileAutoscaler(hpa, key)  
}

HorizontalController.reconcileAutoscaler 调谐 autoscaling CR 资源:

go 复制代码
func (a *HorizontalController) reconcileAutoscaler(hpav1Shared *autoscalingv1.HorizontalPodAutoscaler, key string) error {
	...
	// 获取 autoscale 的目标资源 scale 和 autoscaling CR targetGR
	scale, targetGR, err := a.scaleForResourceMappings(hpa.Namespace, hpa.Spec.ScaleTargetRef.Name, mappings)  
if err != nil {  
    ... 
    return fmt.Errorf("failed to query scale subresource for %s: %v", reference, err)  
	}
	
	// 记录 scale 的当前副本数
	currentReplicas := scale.Spec.Replicas  
	// 记录初始副本到窗口 window
	a.recordInitialRecommendation(currentReplicas, key)
	...
}

HorizontalController.reconcileAutoscaler 获取要 scale 的目标资源和 autoscaling CR 资源,接着将目前资源的副本数记录到 HorizontalController.recommendations 窗口:

go 复制代码
func (a *HorizontalController) recordInitialRecommendation(currentReplicas int32, key string) {  
    if a.recommendations[key] == nil {  
       a.recommendations[key] = []timestampedRecommendation{{currentReplicas, time.Now()}}  
    }  
}

hpa 控制器根据 autoscaling CR 配置的行为和窗口来确定要伸缩的期望副本数。

拉取指标

HorizontalController.computeReplicasForMetrics 拉取指标并根据指标计算期望伸缩副本数。

go 复制代码
func (a *HorizontalController) computeReplicasForMetrics(hpa *autoscalingv2.HorizontalPodAutoscaler, scale *autoscalingv1.Scale,metricSpecs []autoscalingv2.MetricSpec) (replicas int32, metric string, statuses []autoscalingv2.MetricStatus, timestamp time.Time, err error) {
	...
	// 分别计算不同类型指标
	// 选择最大值作为期望伸缩副本数
	for i, metricSpec := range metricSpecs {  
		// 计算单类型指标
	    replicaCountProposal, metricNameProposal, timestampProposal, condition, err := a.computeReplicasForMetric(hpa, metricSpec, specReplicas, statusReplicas, selector, &statuses[i])  
  
	    if err != nil {  
	       ...
	    }  
	    if err == nil && (replicas == 0 || replicaCountProposal > replicas) {  
	       timestamp = timestampProposal  
	       replicas = replicaCountProposal  
	       metric = metricNameProposal  
		}  
	}
	...
	return replicas, metric, statuses, timestamp, nil
}	

实际计算指标期望副本数是在 HorizontalController.computeReplicasForMetric ,其根据不同 autoscaling 指标类型 走不同的 Metrics API 分支:

go 复制代码
func (a *HorizontalController) computeReplicasForMetric(hpa *autoscalingv2.HorizontalPodAutoscaler, spec autoscalingv2.MetricSpec,  
    specReplicas, statusReplicas int32, selector labels.Selector, status *autoscalingv2.MetricStatus) (replicaCountProposal int32, metricNameProposal string,  
    timestampProposal time.Time, condition autoscalingv2.HorizontalPodAutoscalerCondition, err error) {
    // 根据 autoscaling 类型走不通的 Metrics API
    switch spec.Type {  
	case autoscalingv2.ObjectMetricSourceType:
		...
	case autoscalingv2.PodsMetricSourceType:
		...
	case autoscalingv2.ResourceMetricSourceType:
		replicaCountProposal, timestampProposal, metricNameProposal, condition, err = a.computeStatusForResourceMetric(specReplicas, spec, hpa, selector, status)  
	case autoscalingv2.ContainerResourceMetricSourceType:
		...
	case autoscalingv2.ExternalMetricSourceType:
		...
	default:
		...
		return 0, "", time.Time{}, condition, err
	}
	return replicaCountProposal, metricNameProposal, timestampProposal, autoscalingv2.HorizontalPodAutoscalerCondition{}, nil
}

以 autoscalingv2.ResourceMetricSourceType 资源指标类型为例,计算期望副本数。

计算流程如下:

  1. 调用 metrics server client 获取 pod 指标数据;
  2. 根据 autoscaling CR 中配置的 podSelector 获取 pod 列表;
  3. 结合 pod 列表和 pod 指标数据生成 readyPodCount, unreadyPods, missingPods, ignoredPods 四类 pod 数据;

在流程 3 中返回的四类数据表示:

变量名 类型 含义 归类条件 HPA 计算中的处理逻辑
readyPodCount int32 就绪且有有效指标的 Pod 数量(基线分母) 1. 在 podList 里(属于 HPA 管的 workload); 2. Pod Condition Ready=true; 3. 不在 ignoredPods 里; 4. 在 metrics 里有有效数据 1. 无异常时 :新副本数 = ceil(usageRatio × readyPodCount); 2. 有 missing/unready 时:参与重算的基线参考
unreadyPods sets.Set[string] 未就绪的 Pod 集合 1. 在 podList 里; 2. Pod Condition Ready=false(探针未通过、还在启动、CrashLoopBackOff 等) 1. 先从 metrics 里删除 (不参与第一次计算); 2. 想扩容时 (usageRatio > 1.0):把它们当作"使用率 0%"加回 metrics 重算(保守对待扩容); 3. 想缩容时:不计入分母(避免缩掉还没启动的 Pod)
missingPods sets.Set[string] 指标缺失的 Pod 集合 1. 在 podList 里(期望存在); 2. 但在 metrics 里完全找不到(kubelet 挂了、metrics-server 漏采、Pod 刚创建还没数据) 1. 想扩容时 (usageRatio > 1.0):当作"使用率 0%"(最不利于扩容的保守值,防止盲目加 Pod); 2. 想缩容时 (usageRatio < 1.0):当作"使用率 100% 或 target"(最不利于缩容的保守值,防止误删 Pod); 3. 重算后若方向翻转/落入 tolerance 区间,直接返回当前副本数(不动)
ignoredPods sets.Set[string] 被 HPA 主动忽略的 Pod 集合 1. 在 podList 里; 2. 满足以下任一条件 : a. 处于 CPU 初始化期 (默认创建后 ≤ 2min,或 Ready 后 ≤ 10s 的不稳定窗口); b. 被打 autoscaling.kubernetes.io/suspend 注解; c. 处于 Deleting 状态 直接从 metrics 里永久移除,完全不参与任何计算------相当于这些 Pod 对 HPA "透明"

这四类数据的作用是使 hpa 控制器去除不可靠 pod,用保守值兜底,核心是为快扩慢缩服务。

当获取指标和 pod 信息后,就可以用它们根据水平伸缩算法算出期望副本数了。

水平伸缩算法

水平伸缩算法流程如下:
flowchart TD A"groupPods 分组\
podList + metrics → 四类"
--> B{"无 missing 且<br/>无 unready 想扩?"} B -->|是| C{"usageRatio 在<br/>tolerance 内?"} C -->|是| D"返回 currentReplicas\
不动"
C -->|否| E"ceil(usageRatio × readyPodCount)" B -->|否| F"给 missingPods 兜底赋值\
缩时=100% / 扩时=0%"
F --> G"给 unreadyPods 兜底\
仅扩时=0%"
G --> H"重算 newUsageRatio" H --> I{"方向翻转<br/>或在 tolerance 内?"} I -->|是| D I -->|否| J"newReplicas = ceil(newUsageRatio × len(metrics))" J --> K{"newReplicas 方向反转?"} K -->|是| D K -->|否| L"返回 newReplicas"

时间窗

为防止短期的指标抖动导致频繁扩缩容(通常是缩容时用时间窗防止缩太多副本导致服务不可用),hpa 控制器引入时间窗根据一段时间内的期望值来确定最终要伸缩的期望值。

hpa 控制器通过环形队列实现时间窗,实现如下:

go 复制代码
// stabilizeRecommendation:  
// - replaces old recommendation with the newest recommendation,  
// - returns max of recommendations that are not older than downscaleStabilisationWindow.  
func (a *HorizontalController) stabilizeRecommendation(key string, prenormalizedDesiredReplicas int32) int32 {  
    maxRecommendation := prenormalizedDesiredReplicas  
    foundOldSample := false  
    oldSampleIndex := 0  
    cutoff := time.Now().Add(-a.downscaleStabilisationWindow)  
    for i, rec := range a.recommendations[key] {  
       if rec.timestamp.Before(cutoff) {  
          foundOldSample = true  
          oldSampleIndex = i  
       } else if rec.recommendation > maxRecommendation {  
          maxRecommendation = rec.recommendation  
       }  
    }  
    if foundOldSample {  
       a.recommendations[key][oldSampleIndex] = timestampedRecommendation{prenormalizedDesiredReplicas, time.Now()}  
    } else {  
       a.recommendations[key] = append(a.recommendations[key], timestampedRecommendation{prenormalizedDesiredReplicas, time.Now()})  
    }  
    return maxRecommendation  
}

性能

hpa 控制器基于拉模型,默认每隔 15s 从 Metrics Server 拉取指标,并计算期望伸缩副本数。对于大部分场景是够用了,但是对于高并发瞬时请求导致的扩容, hpa 控制器并不能及时响应,可能会导致服务不可用。

并且扩容出的新副本离提供服务还有一定距离:

  • 容器镜像要下载;
  • 容器要启动;
  • 探针检查要通过;

对于大容器镜像,这里快速扩容还要搭配快速加载镜像一起使用,否则也会造成服务不可用。

这里提出了性能问题,后续文章会介绍如何降低水平自动伸缩的性能问题。

参考资料