cdk8s-plus-36 0.0.1 → 2.0.0

package/lib/horizontal-pod-autoscaler.js

@@ -0,0 +1,629 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Replicas = exports.ScalingStrategy = exports.MetricTarget = exports.Metric = exports.HorizontalPodAutoscaler = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdk8s_1 = require("cdk8s");
+const base_1 = require("./base");
+const k8s = __importStar(require("./imports/k8s"));
+/**
+ * A HorizontalPodAutoscaler scales a workload up or down in response to a metric
+ * change. This allows your services to scale up when demand is high and scale down
+ * when they are no longer needed.
+ *
+ *
+ * Typical use cases for HorizontalPodAutoscaler:
+ *
+ * * When Memory usage is above 70%, scale up the number of replicas to meet the demand.
+ * * When CPU usage is below 30%, scale down the number of replicas to save resources.
+ * * When a service is experiencing a spike in traffic, scale up the number of replicas
+ *   to meet the demand. Then, when the traffic subsides, scale down the number of
+ *   replicas to save resources.
+ *
+ * The autoscaler uses the following algorithm to determine the number of replicas to scale:
+ *
+ * `desiredReplicas = ceil[currentReplicas * ( currentMetricValue / desiredMetricValue )]`
+ *
+ * HorizontalPodAutoscaler's can be used to with any `Scalable` workload:
+ * * Deployment
+ * * StatefulSet
+ *
+ * **Targets that already have a replica count defined:**
+ *
+ * Remove any replica counts from the target resource before associating with a
+ * HorizontalPodAutoscaler. If this isn't done, then any time a change to that object is applied,
+ * Kubernetes will scale the current number of Pods to the value of the target.replicas key. This
+ * may not be desired and could lead to unexpected behavior.
+ *
+ * @see https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/#implicit-maintenance-mode-deactivation
+ *
+ * @example
+ * const backend = new kplus.Deployment(this, 'Backend', ...);
+ *
+ * const hpa = new kplus.HorizontalPodAutoscaler(chart, 'Hpa', {
+ *  target: backend,
+ *  maxReplicas: 10,
+ *  scaleUp: {
+ *    policies: [
+ *      {
+ *        replicas: kplus.Replicas.absolute(3),
+ *        duration: Duration.minutes(5),
+ *      },
+ *    ],
+ *  },
+ * });
+ */
+class HorizontalPodAutoscaler extends base_1.Resource {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.HorizontalPodAutoscaler", version: "2.0.0" };
+    /**
+   * @see base.Resource.apiObject
+   */
+    apiObject;
+    resourceType = 'horizontalpodautoscaler';
+    /**
+     * The workload to scale up or down.
+     */
+    target;
+    /**
+     * The maximum number of replicas that can be scaled up to.
+     */
+    maxReplicas;
+    /**
+     * The minimum number of replicas that can be scaled down to.
+     */
+    minReplicas;
+    /**
+     * The metric conditions that trigger a scale up or scale down.
+     */
+    metrics;
+    /**
+     * The scaling behavior when scaling up.
+     */
+    scaleUp;
+    /**
+     * The scaling behavior when scaling down.
+     */
+    scaleDown;
+    _defaultScalingDuration = cdk8s_1.Duration.seconds(15);
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.apiObject = new k8s.KubeHorizontalPodAutoscalerV2(this, 'Resource', {
+            metadata: props.metadata,
+            spec: cdk8s_1.Lazy.any({ produce: () => this._toKube() }),
+        });
+        if (props?.minReplicas && props.minReplicas > props.maxReplicas) {
+            throw new Error(`'minReplicas' (${props.minReplicas}) must be less than or equal to 'maxReplicas' (${props.maxReplicas}) in order for HorizontalPodAutoscaler to scale.`);
+        }
+        if (props?.scaleUp?.stabilizationWindow !== undefined) {
+            this._validateStabilizationWindow('scaleUp', props.scaleUp.stabilizationWindow);
+        }
+        if (props?.scaleDown?.stabilizationWindow !== undefined) {
+            this._validateStabilizationWindow('scaleDown', props.scaleDown.stabilizationWindow);
+        }
+        if (props?.scaleUp?.policies?.length) {
+            this._validateScalingPolicies('scaleUp', props.scaleUp.policies);
+        }
+        if (props?.scaleDown?.policies?.length) {
+            this._validateScalingPolicies('scaleDown', props.scaleDown.policies);
+        }
+        this.target = props.target;
+        this.target.markHasAutoscaler();
+        this.maxReplicas = props.maxReplicas;
+        this.minReplicas = props.minReplicas ?? 1;
+        this.metrics = props.metrics;
+        this.scaleUp = {
+            strategy: ScalingStrategy.MAX_CHANGE,
+            stabilizationWindow: cdk8s_1.Duration.seconds(0),
+            ...props.scaleUp,
+            policies: props.scaleUp?.policies?.map((p) => ({ duration: this._defaultScalingDuration, ...p })) ?? [
+                {
+                    replicas: Replicas.absolute(4),
+                    duration: cdk8s_1.Duration.minutes(1),
+                },
+                {
+                    replicas: Replicas.percent(200),
+                    duration: cdk8s_1.Duration.minutes(1),
+                },
+            ],
+        };
+        if (props?.scaleUp?.policies?.length) {
+            this._validateScalingPolicies('scaleUp', props.scaleUp.policies);
+        }
+        this.scaleDown = {
+            strategy: ScalingStrategy.MAX_CHANGE,
+            stabilizationWindow: cdk8s_1.Duration.minutes(5),
+            ...props.scaleDown,
+            policies: props.scaleDown?.policies?.map((p) => ({ duration: this._defaultScalingDuration, ...p })) ?? [
+                {
+                    replicas: Replicas.absolute(this.minReplicas),
+                    duration: cdk8s_1.Duration.minutes(5),
+                },
+            ],
+        };
+        this.node.addValidation({ validate: () => this._validateTargetReplicas() });
+        this.node.addValidation({ validate: () => this._validateTargetContainers() });
+    }
+    /**
+     * Validate a list of scaling policies.
+     * @internal
+     */
+    _validateScalingPolicies(direction, policies) {
+        policies.forEach((p) => {
+            if (p.duration !== undefined) {
+                this._validateScalingPolicyDuration(direction, p.duration);
+            }
+        });
+    }
+    /**
+     * Validate `ScalingPolicy.duration` is within the allowed range.
+     *
+     * `duration` range: 1 second - 30 min
+     *
+     * Kubernetes name: `ScalingPolicy.periodSeconds`.
+     * @see https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/horizontal-pod-autoscaler-v2/#HorizontalPodAutoscalerSpec
+     * @internal
+     */
+    _validateScalingPolicyDuration(direction, duration) {
+        const periodSeconds = duration.toSeconds() ?? 15;
+        const isWithinRange = Boolean(0 < periodSeconds && periodSeconds <= 1800);
+        if (!isWithinRange) {
+            throw new Error(`'${direction}.policies' duration (${duration.toHumanString()}) is outside of the allowed range. Must be at least 1 second long and no longer than 30 minutes.`);
+        }
+    }
+    /**
+     * Validate `ScalingRules.stabilizationWindow` is within the allowed range.
+     *
+     * `stabilizationWindow` range: 0 seconds - 1 hour
+     *
+     * @see https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/horizontal-pod-autoscaler-v2/#HorizontalPodAutoscalerSpec
+     * @internal
+     */
+    _validateStabilizationWindow(direction, window) {
+        const windowSeconds = window.toSeconds();
+        const isWithinRange = Boolean(0 <= windowSeconds && windowSeconds <= 3600);
+        if (!isWithinRange) {
+            throw new Error(`'${direction}.stabilizationWindow' (${window.toHumanString()}) must be 0 seconds or more with a max of 1 hour.`);
+        }
+    }
+    /**
+     * Guarantee the HPA has a metric to scale on.
+     * Verify that metrics are configured, if not check every pod container has a resource limit or
+     * request defined.
+     * @internal
+     */
+    _validateTargetContainers() {
+        const containers = this.target.toScalingTarget().containers;
+        const hasResourceConstraints = containers.some((c) => this._hasRequestsOrLimits(c));
+        if (!hasResourceConstraints && !this.metrics) {
+            return ['If HorizontalPodAutoscaler does not have metrics defined, then every container in the target must have a CPU or memory resource constraint defined.'];
+        }
+        return [];
+    }
+    /**
+     * Prevent the HPA from scaling a target with a replica count defined.
+     * @see https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/#implicit-maintenance-mode-deactivation
+     * @internal
+     */
+    _validateTargetReplicas() {
+        const replicas = this.target.toScalingTarget().replicas;
+        if (replicas) {
+            return [
+                `HorizontalPodAutoscaler target cannot have a fixed number of replicas (${replicas}).`,
+            ];
+        }
+        return [];
+    }
+    /**
+     * Validate that the container has at least one CPU/memory request/limit defined.
+     * @internal
+     */
+    _hasRequestsOrLimits(c) {
+        const hasRequests = c.resources?.cpu?.request || c.resources?.memory?.request;
+        const hasLimits = c.resources?.cpu?.limit || c.resources?.memory?.limit;
+        return Boolean(hasRequests || hasLimits);
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        const scalingTarget = this.target.toScalingTarget();
+        return {
+            maxReplicas: this.maxReplicas,
+            minReplicas: this.minReplicas,
+            scaleTargetRef: {
+                apiVersion: scalingTarget.apiVersion,
+                name: scalingTarget.name,
+                kind: scalingTarget.kind,
+            },
+            metrics: this.metrics?.map(m => m._toKube()),
+            behavior: {
+                scaleUp: {
+                    policies: this.scaleUp.policies?.map((p) => ({
+                        ...p.replicas._toKube(),
+                        periodSeconds: p.duration?.toSeconds() ?? this._defaultScalingDuration.toSeconds(),
+                    })),
+                    selectPolicy: this.scaleUp.strategy,
+                    stabilizationWindowSeconds: this.scaleUp.stabilizationWindow?.toSeconds(),
+                },
+                scaleDown: {
+                    policies: this.scaleDown.policies?.map((p) => ({
+                        ...p.replicas._toKube(),
+                        periodSeconds: p.duration?.toSeconds() ?? this._defaultScalingDuration.toSeconds(),
+                    })),
+                    selectPolicy: this.scaleDown.strategy,
+                    stabilizationWindowSeconds: this.scaleDown.stabilizationWindow?.toSeconds(),
+                },
+            },
+        };
+    }
+}
+exports.HorizontalPodAutoscaler = HorizontalPodAutoscaler;
+/**
+ * A metric condition that HorizontalPodAutoscaler's scale on.
+ */
+class Metric {
+    metric;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.Metric", version: "2.0.0" };
+    /**
+     * Metric that tracks the CPU of a container. This metric
+     * will be tracked across all pods of the current scale target.
+     *
+     */
+    static containerCpu(options) {
+        return new Metric({
+            type: 'ContainerResource',
+            containerResource: {
+                name: 'cpu',
+                container: options.container.name,
+                target: options.target._toKube(),
+            },
+        });
+    }
+    /**
+     * Metric that tracks the Memory of a container. This metric
+     * will be tracked across all pods of the current scale target.
+     *
+     */
+    static containerMemory(options) {
+        return new Metric({
+            type: 'ContainerResource',
+            containerResource: {
+                name: 'memory',
+                container: options.container.name,
+                target: options.target._toKube(),
+            },
+        });
+    }
+    /**
+     * Metric that tracks the volume size of a container. This metric
+     * will be tracked across all pods of the current scale target.
+     *
+     */
+    static containerStorage(options) {
+        return new Metric({
+            type: 'ContainerResource',
+            containerResource: {
+                name: 'storage',
+                container: options.container.name,
+                target: options.target._toKube(),
+            },
+        });
+    }
+    /**
+     * Metric that tracks the local ephemeral storage of a container. This metric
+     * will be tracked across all pods of the current scale target.
+     *
+     */
+    static containerEphemeralStorage(options) {
+        return new Metric({
+            type: 'ContainerResource',
+            containerResource: {
+                name: 'ephemeral-storage',
+                container: options.container.name,
+                target: options.target._toKube(),
+            },
+        });
+    }
+    /**
+     * A global metric that is not associated with any Kubernetes object.
+     * Allows for autoscaling based on information coming from components running outside of
+     * the cluster.
+     *
+     * Use case:
+     * * Scale up when the length of an SQS queue is greater than 10 messages.
+     * * Scale down when an outside load balancer's queries are less than 10000 per second.
+     */
+    static external(options) {
+        return new Metric({
+            type: 'External',
+            external: {
+                metric: {
+                    name: options.name,
+                    selector: options.labelSelector?._toKube(),
+                },
+                target: options.target._toKube(),
+            },
+        });
+    }
+    /**
+    * Metric that describes a metric of a kubernetes object
+    *
+    * Use case:
+    * * Scale on a Kubernetes Ingress's hits-per-second metric.
+    */
+    static object(options) {
+        return new Metric({
+            type: 'Object',
+            object: {
+                describedObject: {
+                    apiVersion: options.object.apiVersion,
+                    kind: options.object.kind,
+                    name: options.object.name,
+                },
+                metric: {
+                    name: options.name,
+                    selector: options.labelSelector?._toKube(),
+                },
+                target: options.target._toKube(),
+            },
+        });
+    }
+    /**
+     * A pod metric that will be averaged across all pods of the current scale target.
+     *
+     * Use case:
+     * * Average CPU utilization across all pods
+     * * Transactions processed per second across all pods
+     */
+    static pods(options) {
+        return new Metric({
+            type: 'Pods',
+            pods: {
+                metric: {
+                    name: options.name,
+                    selector: options.labelSelector?._toKube(),
+                },
+                target: options.target._toKube(),
+            },
+        });
+    }
+    /**
+     * Tracks the available CPU of the pods in a target.
+     *
+     * Note: Since the resource usages of all the containers are summed up the total
+     * pod utilization may not accurately represent the individual container resource
+     * usage. This could lead to situations where a single container might be running
+     * with high usage and the HPA will not scale out because the overall pod usage
+     * is still within acceptable limits.
+     *
+     * Use case:
+     * * Scale up when CPU is above 40%.
+     */
+    static resourceCpu(target) {
+        return new Metric({
+            type: 'Resource',
+            resource: {
+                name: 'cpu',
+                target: target._toKube(),
+            },
+        });
+    }
+    /**
+     * Tracks the available Memory of the pods in a target.
+     *
+     * Note: Since the resource usages of all the containers are summed up the total
+     * pod utilization may not accurately represent the individual container resource
+     * usage. This could lead to situations where a single container might be running
+     * with high usage and the HPA will not scale out because the overall pod usage
+     * is still within acceptable limits.
+     *
+     * Use case:
+     * * Scale up when Memory is above 512MB.
+     */
+    static resourceMemory(target) {
+        return new Metric({
+            type: 'Resource',
+            resource: {
+                name: 'memory',
+                target: target._toKube(),
+            },
+        });
+    }
+    /**
+     * Tracks the available Storage of the pods in a target.
+     *
+     * Note: Since the resource usages of all the containers are summed up the total
+     * pod utilization may not accurately represent the individual container resource
+     * usage. This could lead to situations where a single container might be running
+     * with high usage and the HPA will not scale out because the overall pod usage
+     * is still within acceptable limits.
+     *
+     */
+    static resourceStorage(target) {
+        return new Metric({
+            type: 'Resource',
+            resource: {
+                name: 'storage',
+                target: target._toKube(),
+            },
+        });
+    }
+    /**
+     * Tracks the available Ephemeral Storage of the pods in a target.
+     *
+     * Note: Since the resource usages of all the containers are summed up the total
+     * pod utilization may not accurately represent the individual container resource
+     * usage. This could lead to situations where a single container might be running
+     * with high usage and the HPA will not scale out because the overall pod usage
+     * is still within acceptable limits.
+     *
+     */
+    static resourceEphemeralStorage(target) {
+        return new Metric({
+            type: 'Resource',
+            resource: {
+                name: 'ephemeral-storage',
+                target: target._toKube(),
+            },
+        });
+    }
+    type;
+    constructor(metric) {
+        this.metric = metric;
+        this.type = metric.type;
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        return this.metric;
+    }
+}
+exports.Metric = Metric;
+/**
+ * A metric condition that will trigger scaling behavior when satisfied.
+ *
+ * @example
+ *
+ * MetricTarget.averageUtilization(70); // 70% average utilization
+ *
+ */
+class MetricTarget {
+    metric;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.MetricTarget", version: "2.0.0" };
+    /**
+    * Target a specific target value.
+    *
+    * @param value The target value.
+    */
+    static value(value) {
+        return new MetricTarget({
+            type: 'Value',
+            value: k8s.Quantity.fromNumber(value),
+        });
+    }
+    /**
+     * Target the average value across all relevant pods.
+     *
+     * @param averageValue The average metric value.
+     */
+    static averageValue(averageValue) {
+        return new MetricTarget({
+            type: 'AverageValue',
+            averageValue: k8s.Quantity.fromNumber(averageValue),
+        });
+    }
+    /**
+     * Target a percentage value across all relevant pods.
+     *
+     * @param averageUtilization The percentage of the utilization metric. e.g. `50` for 50%.
+     */
+    static averageUtilization(averageUtilization) {
+        return new MetricTarget({
+            type: 'Utilization',
+            averageUtilization,
+        });
+    }
+    constructor(metric) {
+        this.metric = metric;
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        return this.metric;
+    }
+}
+exports.MetricTarget = MetricTarget;
+var ScalingStrategy;
+(function (ScalingStrategy) {
+    /**
+     * Use the policy that provisions the most changes.
+     */
+    ScalingStrategy["MAX_CHANGE"] = "Max";
+    /**
+     * Use the policy that provisions the least amount of changes.
+     */
+    ScalingStrategy["MIN_CHANGE"] = "Min";
+    /**
+     * Disables scaling in this direction.
+     *
+     * @deprecated - Omit the ScalingRule instead
+     */
+    ScalingStrategy["DISABLED"] = "Disabled";
+})(ScalingStrategy || (exports.ScalingStrategy = ScalingStrategy = {}));
+/**
+ * The amount of replicas that will change.
+ */
+class Replicas {
+    replicas;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.Replicas", version: "2.0.0" };
+    /**
+     * Changes the pods by a percentage of the it's current value.
+     *
+     * @param value The percentage of change to apply. Must be greater than 0.
+     */
+    static percent(value) {
+        return new Replicas({
+            type: 'Percent',
+            value,
+        });
+    }
+    /**
+     * Changes the pods by a percentage of the it's current value.
+     *
+     * @param value The amount of change to apply. Must be greater than 0.
+     */
+    static absolute(value) {
+        return new Replicas({
+            type: 'Pods',
+            value,
+        });
+    }
+    constructor(replicas) {
+        this.replicas = replicas;
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        return {
+            type: this.replicas.type,
+            value: this.replicas.value,
+        };
+    }
+}
+exports.Replicas = Replicas;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"horizontal-pod-autoscaler.js","sourceRoot":"","sources":["../src/horizontal-pod-autoscaler.ts"],"names":[],"mappings":"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","sourcesContent":["import { ApiObject, Duration, Lazy } from 'cdk8s';\nimport { Construct } from 'constructs';\nimport { Resource, ResourceProps, IResource } from './base';\nimport * as container from './container';\nimport * as k8s from './imports/k8s';\nimport * as pod from './pod';\n\n\n/**\n * Properties used to configure the target of an Autoscaler.\n */\nexport interface ScalingTarget {\n  /**\n   * The object kind (e.g. \"Deployment\").\n   */\n  readonly kind: string;\n  /**\n   * The object's API version (e.g. \"authorization.k8s.io/v1\")\n   */\n  readonly apiVersion: string;\n  /**\n   * The Kubernetes name of this resource.\n   */\n  readonly name: string;\n  /**\n   * Container definitions associated with the target.\n   */\n  readonly containers: container.Container[];\n  /**\n   * The fixed number of replicas defined on the target. This is used\n   * for validation purposes as Scalable targets should not have a\n   * fixed number of replicas.\n   */\n  readonly replicas?: number;\n\n\n}\n\n/**\n * Represents a scalable workload.\n */\nexport interface IScalable {\n  /**\n   * If this is a target of an autoscaler.\n   */\n  hasAutoscaler: boolean;\n  /**\n   * Called on all IScalable targets when they are associated with an autoscaler.\n   */\n  markHasAutoscaler(): void;\n  /**\n   * Return the target spec properties of this Scalable.\n   */\n  toScalingTarget(): ScalingTarget;\n}\n\n/**\n * Properties for HorizontalPodAutoscaler\n */\nexport interface HorizontalPodAutoscalerProps extends ResourceProps {\n  /**\n   * The workload to scale up or down.\n   *\n   * Scalable workload types:\n   * * Deployment\n   * * StatefulSet\n   */\n  readonly target: IScalable;\n  /**\n   * The maximum number of replicas that can be scaled up to.\n   */\n  readonly maxReplicas: number;\n  /**\n   * The minimum number of replicas that can be scaled down to.\n   *\n   * Can be set to 0 if the alpha feature gate `HPAScaleToZero` is enabled and\n   * at least one Object or External metric is configured.\n   *\n   * @default 1\n   */\n  readonly minReplicas?: number;\n  /**\n   * The metric conditions that trigger a scale up or scale down.\n   *\n   * @default - If metrics are not provided, then the target resource\n   * constraints (e.g. cpu limit) will be used as scaling metrics.\n   */\n  readonly metrics?: Metric[];\n  /**\n   * The scaling behavior when scaling up.\n   *\n   * @default - Is the higher of:\n   * * Increase no more than 4 pods per 60 seconds\n   * * Double the number of pods per 60 seconds\n   */\n  readonly scaleUp?: ScalingRules;\n  /**\n   * The scaling behavior when scaling down.\n   *\n   * @default - Scale down to minReplica count with a 5 minute stabilization window.\n   */\n  readonly scaleDown?: ScalingRules;\n}\n\n/**\n * A HorizontalPodAutoscaler scales a workload up or down in response to a metric\n * change. This allows your services to scale up when demand is high and scale down\n * when they are no longer needed.\n *\n *\n * Typical use cases for HorizontalPodAutoscaler:\n *\n * * When Memory usage is above 70%, scale up the number of replicas to meet the demand.\n * * When CPU usage is below 30%, scale down the number of replicas to save resources.\n * * When a service is experiencing a spike in traffic, scale up the number of replicas\n *   to meet the demand. Then, when the traffic subsides, scale down the number of\n *   replicas to save resources.\n *\n * The autoscaler uses the following algorithm to determine the number of replicas to scale:\n *\n * `desiredReplicas = ceil[currentReplicas * ( currentMetricValue / desiredMetricValue )]`\n *\n * HorizontalPodAutoscaler's can be used to with any `Scalable` workload:\n * * Deployment\n * * StatefulSet\n *\n * **Targets that already have a replica count defined:**\n *\n * Remove any replica counts from the target resource before associating with a\n * HorizontalPodAutoscaler. If this isn't done, then any time a change to that object is applied,\n * Kubernetes will scale the current number of Pods to the value of the target.replicas key. This\n * may not be desired and could lead to unexpected behavior.\n *\n * @see https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/#implicit-maintenance-mode-deactivation\n *\n * @example\n * const backend = new kplus.Deployment(this, 'Backend', ...);\n *\n * const hpa = new kplus.HorizontalPodAutoscaler(chart, 'Hpa', {\n *  target: backend,\n *  maxReplicas: 10,\n *  scaleUp: {\n *    policies: [\n *      {\n *        replicas: kplus.Replicas.absolute(3),\n *        duration: Duration.minutes(5),\n *      },\n *    ],\n *  },\n * });\n */\nexport class HorizontalPodAutoscaler extends Resource {\n  /**\n * @see base.Resource.apiObject\n */\n  protected readonly apiObject: ApiObject;\n  public readonly resourceType = 'horizontalpodautoscaler';\n  /**\n   * The workload to scale up or down.\n   */\n  public readonly target: IScalable;\n  /**\n   * The maximum number of replicas that can be scaled up to.\n   */\n  public readonly maxReplicas: number;\n  /**\n   * The minimum number of replicas that can be scaled down to.\n   */\n  public readonly minReplicas: number;\n  /**\n   * The metric conditions that trigger a scale up or scale down.\n   */\n  public readonly metrics?: Metric[];\n  /**\n   * The scaling behavior when scaling up.\n   */\n  public readonly scaleUp: ScalingRules;\n  /**\n   * The scaling behavior when scaling down.\n   */\n  public readonly scaleDown: ScalingRules;\n\n  private readonly _defaultScalingDuration = Duration.seconds(15);\n\n\n  constructor(scope: Construct, id: string, props: HorizontalPodAutoscalerProps) {\n    super(scope, id);\n\n    this.apiObject = new k8s.KubeHorizontalPodAutoscalerV2(this, 'Resource', {\n      metadata: props.metadata,\n      spec: Lazy.any({ produce: () => this._toKube() }),\n    });\n\n    if (props?.minReplicas && props.minReplicas > props.maxReplicas) {\n      throw new Error(`'minReplicas' (${props.minReplicas}) must be less than or equal to 'maxReplicas' (${props.maxReplicas}) in order for HorizontalPodAutoscaler to scale.`);\n    }\n    if (props?.scaleUp?.stabilizationWindow !== undefined) {\n      this._validateStabilizationWindow('scaleUp', props.scaleUp.stabilizationWindow);\n    }\n    if (props?.scaleDown?.stabilizationWindow !== undefined) {\n      this._validateStabilizationWindow('scaleDown', props.scaleDown.stabilizationWindow);\n    }\n    if (props?.scaleUp?.policies?.length) {\n      this._validateScalingPolicies('scaleUp', props.scaleUp.policies);\n    }\n    if (props?.scaleDown?.policies?.length) {\n      this._validateScalingPolicies('scaleDown', props.scaleDown.policies);\n    }\n\n    this.target = props.target;\n    this.target.markHasAutoscaler();\n    this.maxReplicas = props.maxReplicas;\n    this.minReplicas = props.minReplicas ?? 1;\n    this.metrics = props.metrics;\n    this.scaleUp = {\n      strategy: ScalingStrategy.MAX_CHANGE,\n      stabilizationWindow: Duration.seconds(0),\n      ...props.scaleUp,\n      policies: props.scaleUp?.policies?.map((p) => ({ duration: this._defaultScalingDuration, ...p })) ?? [\n        {\n          replicas: Replicas.absolute(4),\n          duration: Duration.minutes(1),\n        },\n        {\n          replicas: Replicas.percent(200),\n          duration: Duration.minutes(1),\n        },\n      ],\n    };\n    if (props?.scaleUp?.policies?.length) {\n      this._validateScalingPolicies('scaleUp', props.scaleUp.policies);\n    }\n    this.scaleDown = {\n      strategy: ScalingStrategy.MAX_CHANGE,\n      stabilizationWindow: Duration.minutes(5),\n      ...props.scaleDown,\n      policies: props.scaleDown?.policies?.map((p) => ({ duration: this._defaultScalingDuration, ...p })) ?? [\n        {\n          replicas: Replicas.absolute(this.minReplicas),\n          duration: Duration.minutes(5),\n        },\n      ],\n    };\n\n    this.node.addValidation({ validate: () => this._validateTargetReplicas() });\n    this.node.addValidation({ validate: () => this._validateTargetContainers() });\n  }\n\n  /**\n   * Validate a list of scaling policies.\n   * @internal\n   */\n  private _validateScalingPolicies(direction: 'scaleUp' | 'scaleDown', policies: ScalingPolicy[]) {\n    policies.forEach((p) => {\n      if (p.duration !== undefined) {\n        this._validateScalingPolicyDuration(direction, p.duration);\n      }\n    });\n  }\n\n  /**\n   * Validate `ScalingPolicy.duration` is within the allowed range.\n   *\n   * `duration` range: 1 second - 30 min\n   *\n   * Kubernetes name: `ScalingPolicy.periodSeconds`.\n   * @see https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/horizontal-pod-autoscaler-v2/#HorizontalPodAutoscalerSpec\n   * @internal\n   */\n  private _validateScalingPolicyDuration(direction: 'scaleUp' | 'scaleDown', duration: Duration) {\n    const periodSeconds = duration.toSeconds() ?? 15;\n    const isWithinRange = Boolean(0 < periodSeconds && periodSeconds <= 1800);\n    if (!isWithinRange) {\n      throw new Error(`'${direction}.policies' duration (${duration.toHumanString()}) is outside of the allowed range. Must be at least 1 second long and no longer than 30 minutes.`);\n    }\n  }\n\n  /**\n   * Validate `ScalingRules.stabilizationWindow` is within the allowed range.\n   *\n   * `stabilizationWindow` range: 0 seconds - 1 hour\n   *\n   * @see https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/horizontal-pod-autoscaler-v2/#HorizontalPodAutoscalerSpec\n   * @internal\n   */\n  private _validateStabilizationWindow(direction: 'scaleUp' | 'scaleDown', window: Duration) {\n    const windowSeconds = window.toSeconds();\n    const isWithinRange = Boolean(0 <= windowSeconds && windowSeconds <= 3600);\n    if (!isWithinRange) {\n      throw new Error(`'${direction}.stabilizationWindow' (${window.toHumanString()}) must be 0 seconds or more with a max of 1 hour.`);\n    }\n  }\n\n  /**\n   * Guarantee the HPA has a metric to scale on.\n   * Verify that metrics are configured, if not check every pod container has a resource limit or\n   * request defined.\n   * @internal\n   */\n  private _validateTargetContainers() {\n    const containers = this.target.toScalingTarget().containers;\n    const hasResourceConstraints = containers.some((c) => this._hasRequestsOrLimits(c));\n    if (!hasResourceConstraints && !this.metrics) {\n      return ['If HorizontalPodAutoscaler does not have metrics defined, then every container in the target must have a CPU or memory resource constraint defined.'];\n    }\n    return [];\n  }\n\n  /**\n   * Prevent the HPA from scaling a target with a replica count defined.\n   * @see https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/#implicit-maintenance-mode-deactivation\n   * @internal\n   */\n  private _validateTargetReplicas() {\n    const replicas = this.target.toScalingTarget().replicas;\n    if (replicas) {\n      return [\n        `HorizontalPodAutoscaler target cannot have a fixed number of replicas (${replicas}).`,\n      ];\n    }\n    return [];\n  }\n\n  /**\n   * Validate that the container has at least one CPU/memory request/limit defined.\n   * @internal\n   */\n  private _hasRequestsOrLimits(c: container.Container): Boolean {\n    const hasRequests = c.resources?.cpu?.request || c.resources?.memory?.request;\n    const hasLimits = c.resources?.cpu?.limit || c.resources?.memory?.limit;\n    return Boolean(hasRequests || hasLimits);\n  }\n\n\n  /**\n   * @internal\n   */\n  public _toKube(): k8s.HorizontalPodAutoscalerSpecV2 {\n    const scalingTarget = this.target.toScalingTarget();\n    return {\n      maxReplicas: this.maxReplicas,\n      minReplicas: this.minReplicas,\n      scaleTargetRef: {\n        apiVersion: scalingTarget.apiVersion,\n        name: scalingTarget.name,\n        kind: scalingTarget.kind,\n      },\n      metrics: this.metrics?.map(m => m._toKube()),\n      behavior: {\n        scaleUp: {\n          policies: this.scaleUp.policies?.map((p) => ({\n            ...p.replicas._toKube(),\n            periodSeconds: p.duration?.toSeconds() ?? this._defaultScalingDuration.toSeconds(),\n          })),\n          selectPolicy: this.scaleUp.strategy,\n          stabilizationWindowSeconds: this.scaleUp.stabilizationWindow?.toSeconds(),\n        },\n        scaleDown: {\n          policies: this.scaleDown.policies?.map((p) => ({\n            ...p.replicas._toKube(),\n            periodSeconds: p.duration?.toSeconds() ?? this._defaultScalingDuration.toSeconds(),\n          })),\n          selectPolicy: this.scaleDown.strategy,\n          stabilizationWindowSeconds: this.scaleDown.stabilizationWindow?.toSeconds(),\n        },\n      },\n    };\n  }\n}\n\n/**\n * Base options for a Metric\n */\nexport interface MetricOptions {\n  /**\n   * The target metric value that will trigger scaling.\n   */\n  readonly target: MetricTarget;\n  /**\n  * The name of the metric to scale on.\n  */\n  readonly name: string;\n  /**\n   * A selector to find a metric by label.\n   *\n   * When set, it is passed as an additional parameter to the metrics server\n   * for more specific metrics scoping.\n   *\n   * @default - Just the metric 'name' will be used to gather metrics.\n   */\n  readonly labelSelector?: pod.LabelSelector;\n}\n\n\n/**\n * Options for `Metric.containerResource()`\n */\nexport interface MetricContainerResourceOptions {\n  /**\n   * Container where the metric can be found.\n   */\n  readonly container: container.Container;\n  /**\n   * Target metric value that will trigger scaling.\n   */\n  readonly target: MetricTarget;\n}\n\n/**\n * Options for `Metric.object()`\n */\nexport interface MetricObjectOptions extends MetricOptions {\n  /**\n   * Resource where the metric can be found.\n   */\n  readonly object: IResource;\n}\n\n/**\n * A metric condition that HorizontalPodAutoscaler's scale on.\n */\nexport class Metric {\n\n  /**\n   * Metric that tracks the CPU of a container. This metric\n   * will be tracked across all pods of the current scale target.\n   *\n   */\n  public static containerCpu(options: MetricContainerResourceOptions): Metric {\n    return new Metric({\n      type: 'ContainerResource',\n      containerResource: {\n        name: 'cpu',\n        container: options.container.name,\n        target: options.target._toKube(),\n      },\n    });\n  }\n\n  /**\n   * Metric that tracks the Memory of a container. This metric\n   * will be tracked across all pods of the current scale target.\n   *\n   */\n  public static containerMemory(options: MetricContainerResourceOptions): Metric {\n    return new Metric({\n      type: 'ContainerResource',\n      containerResource: {\n        name: 'memory',\n        container: options.container.name,\n        target: options.target._toKube(),\n      },\n    });\n  }\n\n  /**\n   * Metric that tracks the volume size of a container. This metric\n   * will be tracked across all pods of the current scale target.\n   *\n   */\n  public static containerStorage(options: MetricContainerResourceOptions): Metric {\n    return new Metric({\n      type: 'ContainerResource',\n      containerResource: {\n        name: 'storage',\n        container: options.container.name,\n        target: options.target._toKube(),\n      },\n    });\n  }\n\n  /**\n   * Metric that tracks the local ephemeral storage of a container. This metric\n   * will be tracked across all pods of the current scale target.\n   *\n   */\n  public static containerEphemeralStorage(options: MetricContainerResourceOptions): Metric {\n    return new Metric({\n      type: 'ContainerResource',\n      containerResource: {\n        name: 'ephemeral-storage',\n        container: options.container.name,\n        target: options.target._toKube(),\n      },\n    });\n  }\n\n  /**\n   * A global metric that is not associated with any Kubernetes object.\n   * Allows for autoscaling based on information coming from components running outside of\n   * the cluster.\n   *\n   * Use case:\n   * * Scale up when the length of an SQS queue is greater than 10 messages.\n   * * Scale down when an outside load balancer's queries are less than 10000 per second.\n   */\n  public static external(options: MetricOptions): Metric {\n    return new Metric({\n      type: 'External',\n      external: {\n        metric: {\n          name: options.name,\n          selector: options.labelSelector?._toKube(),\n        },\n        target: options.target._toKube(),\n      },\n    });\n  }\n\n  /**\n  * Metric that describes a metric of a kubernetes object\n  *\n  * Use case:\n  * * Scale on a Kubernetes Ingress's hits-per-second metric.\n  */\n  public static object(options: MetricObjectOptions): Metric {\n    return new Metric({\n      type: 'Object',\n      object: {\n        describedObject: {\n          apiVersion: options.object.apiVersion,\n          kind: options.object.kind,\n          name: options.object.name,\n        },\n        metric: {\n          name: options.name,\n          selector: options.labelSelector?._toKube(),\n        },\n        target: options.target._toKube(),\n      },\n    });\n  }\n\n  /**\n   * A pod metric that will be averaged across all pods of the current scale target.\n   *\n   * Use case:\n   * * Average CPU utilization across all pods\n   * * Transactions processed per second across all pods\n   */\n  public static pods(options: MetricOptions): Metric {\n    return new Metric({\n      type: 'Pods',\n      pods: {\n        metric: {\n          name: options.name,\n          selector: options.labelSelector?._toKube(),\n        },\n        target: options.target._toKube(),\n      },\n    });\n  }\n\n  /**\n   * Tracks the available CPU of the pods in a target.\n   *\n   * Note: Since the resource usages of all the containers are summed up the total\n   * pod utilization may not accurately represent the individual container resource\n   * usage. This could lead to situations where a single container might be running\n   * with high usage and the HPA will not scale out because the overall pod usage\n   * is still within acceptable limits.\n   *\n   * Use case:\n   * * Scale up when CPU is above 40%.\n   */\n  public static resourceCpu(target: MetricTarget): Metric {\n    return new Metric({\n      type: 'Resource',\n      resource: {\n        name: 'cpu',\n        target: target._toKube(),\n      },\n    });\n  }\n\n  /**\n   * Tracks the available Memory of the pods in a target.\n   *\n   * Note: Since the resource usages of all the containers are summed up the total\n   * pod utilization may not accurately represent the individual container resource\n   * usage. This could lead to situations where a single container might be running\n   * with high usage and the HPA will not scale out because the overall pod usage\n   * is still within acceptable limits.\n   *\n   * Use case:\n   * * Scale up when Memory is above 512MB.\n   */\n  public static resourceMemory(target: MetricTarget): Metric {\n    return new Metric({\n      type: 'Resource',\n      resource: {\n        name: 'memory',\n        target: target._toKube(),\n      },\n    });\n  }\n\n  /**\n   * Tracks the available Storage of the pods in a target.\n   *\n   * Note: Since the resource usages of all the containers are summed up the total\n   * pod utilization may not accurately represent the individual container resource\n   * usage. This could lead to situations where a single container might be running\n   * with high usage and the HPA will not scale out because the overall pod usage\n   * is still within acceptable limits.\n   *\n   */\n  public static resourceStorage(target: MetricTarget): Metric {\n    return new Metric({\n      type: 'Resource',\n      resource: {\n        name: 'storage',\n        target: target._toKube(),\n      },\n    });\n  }\n\n  /**\n   * Tracks the available Ephemeral Storage of the pods in a target.\n   *\n   * Note: Since the resource usages of all the containers are summed up the total\n   * pod utilization may not accurately represent the individual container resource\n   * usage. This could lead to situations where a single container might be running\n   * with high usage and the HPA will not scale out because the overall pod usage\n   * is still within acceptable limits.\n   *\n   */\n  public static resourceEphemeralStorage(target: MetricTarget): Metric {\n    return new Metric({\n      type: 'Resource',\n      resource: {\n        name: 'ephemeral-storage',\n        target: target._toKube(),\n      },\n    });\n  }\n\n  public readonly type: string;\n  private constructor(private readonly metric: k8s.MetricSpecV2) {\n    this.type = metric.type;\n  }\n\n  /**\n   * @internal\n   */\n  public _toKube(): k8s.MetricSpecV2 {\n    return this.metric;\n  }\n\n}\n\n\n/**\n * A metric condition that will trigger scaling behavior when satisfied.\n *\n * @example\n *\n * MetricTarget.averageUtilization(70); // 70% average utilization\n *\n */\nexport class MetricTarget {\n  /**\n  * Target a specific target value.\n  *\n  * @param value The target value.\n  */\n  public static value(value: number): MetricTarget {\n    return new MetricTarget({\n      type: 'Value',\n      value: k8s.Quantity.fromNumber(value),\n    });\n  }\n\n  /**\n   * Target the average value across all relevant pods.\n   *\n   * @param averageValue The average metric value.\n   */\n  public static averageValue(averageValue: number): MetricTarget {\n    return new MetricTarget({\n      type: 'AverageValue',\n      averageValue: k8s.Quantity.fromNumber(averageValue),\n    });\n  }\n\n  /**\n   * Target a percentage value across all relevant pods.\n   *\n   * @param averageUtilization The percentage of the utilization metric. e.g. `50` for 50%.\n   */\n  public static averageUtilization(averageUtilization: number): MetricTarget {\n    return new MetricTarget({\n      type: 'Utilization',\n      averageUtilization,\n    });\n  }\n\n  private constructor(private readonly metric: k8s.MetricTargetV2) { }\n\n  /**\n   * @internal\n   */\n  public _toKube(): k8s.MetricSpecV2 {\n    return this.metric;\n  }\n}\n\n/**\n * Defines the scaling behavior for one direction.\n */\nexport interface ScalingRules {\n  /**\n   * Defines the window of past metrics that the autoscaler should consider when calculating\n   * wether or not autoscaling should occur.\n   *\n   * Minimum duration is 1 second, max is 1 hour.\n   *\n   * @example\n   * stabilizationWindow: Duration.minutes(30)\n   * // Autoscaler considers the last 30 minutes of metrics when deciding whether to scale.\n   *\n   * @default * On scale down no stabilization is performed.\n   * * On scale up stabilization is performed for 5 minutes.\n   */\n  readonly stabilizationWindow?: Duration;\n  /**\n   * The strategy to use when scaling.\n   *\n   * @default MAX_CHANGE\n   */\n  readonly strategy?: ScalingStrategy;\n  /**\n   * The scaling policies.\n   *\n   * @default * Scale up\n   *            * Increase no more than 4 pods per 60 seconds\n   *            * Double the number of pods per 60 seconds\n   *          * Scale down\n   *            * Decrease to minReplica count\n   */\n  readonly policies?: ScalingPolicy[];\n}\n\n\nexport enum ScalingStrategy {\n  /**\n   * Use the policy that provisions the most changes.\n   */\n  MAX_CHANGE = 'Max',\n  /**\n   * Use the policy that provisions the least amount of changes.\n   */\n  MIN_CHANGE = 'Min',\n  /**\n   * Disables scaling in this direction.\n   *\n   * @deprecated - Omit the ScalingRule instead\n   */\n  DISABLED = 'Disabled',\n}\n\nexport interface ScalingPolicy {\n  /**\n   * The type and quantity of replicas to change.\n   */\n  readonly replicas: Replicas;\n  /**\n   * The amount of time the scaling policy has to\n   * continue scaling before the target metric must be\n   * revalidated.\n   *\n   * Must be greater than 0 seconds and no longer than 30 minutes.\n   *\n   * @default - 15 seconds\n   */\n  readonly duration?: Duration;\n}\n\n\n/**\n * The amount of replicas that will change.\n */\nexport class Replicas {\n\n  /**\n   * Changes the pods by a percentage of the it's current value.\n   *\n   * @param value The percentage of change to apply. Must be greater than 0.\n   */\n  public static percent(value: number) {\n    return new Replicas ({\n      type: 'Percent',\n      value,\n    });\n  }\n\n  /**\n   * Changes the pods by a percentage of the it's current value.\n   *\n   * @param value The amount of change to apply. Must be greater than 0.\n   */\n  public static absolute(value: number) {\n    return new Replicas({\n      type: 'Pods',\n      value,\n    });\n  }\n\n  private constructor(private readonly replicas: Pick<k8s.HpaScalingPolicyV2, 'type' | 'value'>) { }\n\n  /**\n   * @internal\n   */\n  public _toKube(): Pick<k8s.HpaScalingPolicyV2, 'type' | 'value'> {\n    return {\n      type: this.replicas.type,\n      value: this.replicas.value,\n    };\n  }\n}\n"]}