autoscaler

README

Scaling documentation has moved to the docs folder.

Documentation

Overview

Package autoscaler calculates the number of pods necessary for the desired level of concurrency per pod (stableConcurrencyPerPod). It operates in two modes, stable mode and panic mode.

Stable mode calculates the average concurrency observed over the last 60 seconds and adjusts the observed pod count to achieve the target value. Current observed pod count is the number of unique pod names which show up in the last 60 seconds.

Panic mode calculates the average concurrency observed over the last 6 seconds and adjusts the observed pod count to achieve the stable target value. Panic mode is engaged when the observed 6 second average concurrency reaches 2x the target stable concurrency. Panic mode will last at least 60 seconds--longer if the 2x threshold is repeatedly breached. During panic mode the number of pods is never decreased in order to prevent flapping.

Package autoscaler supports both single-tenant (one autoscaler per revision) and multitenant (one autoscaler for all revisions) autoscalers; config/controller.yaml determines which kind of autoscaler is used.

Index

• Constants
• func NewKpaKey(namespace string, name string) string
• type Autoscaler
  • func New(dynamicConfig *DynamicConfig, ...) *Autoscaler
  • func (a *Autoscaler) Record(ctx context.Context, stat Stat)
  • func (a *Autoscaler) Scale(ctx context.Context, now time.Time) (int32, bool)
• type Config
  • func NewConfigFromConfigMap(configMap *corev1.ConfigMap) (*Config, error)
  • func NewConfigFromMap(data map[string]string) (*Config, error)
  • func (in *Config) DeepCopy() *Config
  • func (in *Config) DeepCopyInto(out *Config)
  • func (c *Config) TargetConcurrency(concurrency v1alpha1.RevisionContainerConcurrencyType) float64
• type DynamicConfig
  • func NewDynamicConfig(config *Config, logger *zap.SugaredLogger) *DynamicConfig
  • func NewDynamicConfigFromMap(rawConfig map[string]string, logger *zap.SugaredLogger) (*DynamicConfig, error)
  • func (dc *DynamicConfig) Current() *Config
  • func (dc *DynamicConfig) Update(configMap *corev1.ConfigMap)
• type Measurement
• type Metric
• type MultiScaler
  • func NewMultiScaler(dynConfig *DynamicConfig, stopCh <-chan struct{}, ...) *MultiScaler
  • func (m *MultiScaler) Create(ctx context.Context, kpa *kpa.PodAutoscaler) (*Metric, error)
  • func (m *MultiScaler) Delete(ctx context.Context, key string) error
  • func (m *MultiScaler) Get(ctx context.Context, key string) (*Metric, error)
  • func (m *MultiScaler) RecordStat(key string, stat Stat)
  • func (m *MultiScaler) Watch(fn func(string))
• type Reporter
  • func NewStatsReporter(podNamespace string, service string, config string, revision string) (*Reporter, error)
  • func (r *Reporter) Report(m Measurement, v float64) error
• type Stat
• type StatMessage
• type StatsReporter
• type UniScaler
• type UniScalerFactory

Constants

const (
	// ActivatorPodName defines the pod name of the activator
	// as defined in the metrics it sends.
	ActivatorPodName string = "activator"
)

const (
	// ConfigName is the name of the config map of the autoscaler.
	ConfigName = "config-autoscaler"
)

Functions

func NewKpaKey

func NewKpaKey(namespace string, name string) string

NewKpaKey identifies a KPA in the multiscaler. Stats send in are identified and routed via this key.

Types

type Autoscaler

type Autoscaler struct {
	*DynamicConfig
	// contains filtered or unexported fields
}

Autoscaler stores current state of an instance of an autoscaler

func New

func New(dynamicConfig *DynamicConfig, containerConcurrency v1alpha1.RevisionContainerConcurrencyType, reporter StatsReporter) *Autoscaler

New creates a new instance of autoscaler

func (*Autoscaler) Record

func (a *Autoscaler) Record(ctx context.Context, stat Stat)

Record a data point.

func (*Autoscaler) Scale

func (a *Autoscaler) Scale(ctx context.Context, now time.Time) (int32, bool)

Scale calculates the desired scale based on current statistics given the current time.

type Config

type Config struct {
	// Feature flags.
	EnableScaleToZero bool
	EnableVPA         bool

	// Target concurrency knobs for different container concurrency configurations.
	ContainerConcurrencyTargetPercentage float64
	ContainerConcurrencyTargetDefault    float64

	// General autoscaler algorithm configuration.
	MaxScaleUpRate float64
	StableWindow   time.Duration
	PanicWindow    time.Duration
	TickInterval   time.Duration

	ScaleToZeroThreshold   time.Duration
	ScaleToZeroGracePeriod time.Duration
	// This is computed by ScaleToZeroThreshold - ScaleToZeroGracePeriod
	ScaleToZeroIdlePeriod time.Duration
}

Config defines the tunable autoscaler parameters +k8s:deepcopy-gen=true

func NewConfigFromConfigMap

func NewConfigFromConfigMap(configMap *corev1.ConfigMap) (*Config, error)

NewConfigFromConfigMap creates a Config from the supplied ConfigMap

func NewConfigFromMap

func NewConfigFromMap(data map[string]string) (*Config, error)

NewConfigFromMap creates a Config from the supplied map

func (*Config) DeepCopy

func (in *Config) DeepCopy() *Config

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Config.

func (*Config) DeepCopyInto

func (in *Config) DeepCopyInto(out *Config)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*Config) TargetConcurrency

func (c *Config) TargetConcurrency(concurrency v1alpha1.RevisionContainerConcurrencyType) float64

TargetConcurrency calculates the target concurrency for a given container-concurrency taking the container-concurrency-target-percentage into account.

type DynamicConfig

type DynamicConfig struct {
	// contains filtered or unexported fields
}

func NewDynamicConfig

func NewDynamicConfig(config *Config, logger *zap.SugaredLogger) *DynamicConfig

func NewDynamicConfigFromMap

func NewDynamicConfigFromMap(rawConfig map[string]string, logger *zap.SugaredLogger) (*DynamicConfig, error)

func (*DynamicConfig) Current

func (dc *DynamicConfig) Current() *Config

func (*DynamicConfig) Update

func (dc *DynamicConfig) Update(configMap *corev1.ConfigMap)

type Measurement

type Measurement int

Measurement represents the type of the autoscaler metric to be reported

const (
	// DesiredPodCountM is used for the pod count that autoscaler wants
	DesiredPodCountM Measurement = iota
	// RequestedPodCountM is used for the requested pod count from kubernetes
	RequestedPodCountM
	// ActualPodCountM is used for the actual number of pods we have
	ActualPodCountM
	// ObservedPodCountM is used for the observed number of pods we have
	ObservedPodCountM
	// ObservedStableConcurrencyM is the average of requests count in each 60 second stable window
	ObservedStableConcurrencyM
	// ObservedPanicConcurrencyM is the average of requests count in each 6 second panic window
	ObservedPanicConcurrencyM
	// TargetConcurrencyM is the desired number of concurrent requests for each pod
	TargetConcurrencyM
	// PanicM is used as a flag to indicate if autoscaler is in panic mode or not
	PanicM
)

type Metric

type Metric struct {
	DesiredScale int32
}

type MultiScaler

type MultiScaler struct {
	// contains filtered or unexported fields
}

MultiScaler maintains a collection of UniScalers.

func NewMultiScaler

func NewMultiScaler(dynConfig *DynamicConfig, stopCh <-chan struct{}, uniScalerFactory UniScalerFactory, logger *zap.SugaredLogger) *MultiScaler

NewMultiScaler constructs a MultiScaler.

func (*MultiScaler) Create

func (m *MultiScaler) Create(ctx context.Context, kpa *kpa.PodAutoscaler) (*Metric, error)

func (*MultiScaler) Delete

func (m *MultiScaler) Delete(ctx context.Context, key string) error

func (*MultiScaler) Get

func (m *MultiScaler) Get(ctx context.Context, key string) (*Metric, error)

func (*MultiScaler) RecordStat

func (m *MultiScaler) RecordStat(key string, stat Stat)

RecordStat records some statistics for the given KPA. kpaKey should have the form namespace/name.

func (*MultiScaler) Watch

func (m *MultiScaler) Watch(fn func(string))

type Reporter

type Reporter struct {
	// contains filtered or unexported fields
}

Reporter holds cached metric objects to report autoscaler metrics

func NewStatsReporter

func NewStatsReporter(podNamespace string, service string, config string, revision string) (*Reporter, error)

NewStatsReporter creates a reporter that collects and reports autoscaler metrics

func (*Reporter) Report

func (r *Reporter) Report(m Measurement, v float64) error

Report captures value v for measurement m

type Stat

type Stat struct {
	// The time the data point was collected on the pod.
	Time *time.Time

	// The unique identity of this pod.  Used to count how many pods
	// are contributing to the metrics.
	PodName string

	// Average number of requests currently being handled by this pod.
	AverageConcurrentRequests float64

	// Number of requests received since last Stat (approximately QPS).
	RequestCount int32

	// Lameduck indicates this Pod has received a shutdown signal.
	LameDuck bool
}

Stat defines a single measurement at a point in time

type StatMessage

type StatMessage struct {
	Key  string
	Stat Stat
}

StatMessage wraps a Stat with identifying information so it can be routed to the correct receiver.

type StatsReporter

type StatsReporter interface {
	Report(m Measurement, v float64) error
}

StatsReporter defines the interface for sending autoscaler metrics

type UniScaler

type UniScaler interface {
	// Record records the given statistics.
	Record(context.Context, Stat)

	// Scale either proposes a number of replicas or skips proposing. The proposal is requested at the given time.
	// The returned boolean is true if and only if a proposal was returned.
	Scale(context.Context, time.Time) (int32, bool)
}

UniScaler records statistics for a particular KPA and proposes the scale for the KPA's target based on those statistics.

type UniScalerFactory

type UniScalerFactory func(*kpa.PodAutoscaler, *DynamicConfig) (UniScaler, error)

UniScalerFactory creates a UniScaler for a given KPA using the given dynamic configuration.