terraconstructs 0.0.22 → 0.0.24

package/lib/aws/compute/step-scaling-action.d.ts

@@ -0,0 +1,148 @@
+import { Construct } from "constructs";
+import { IScalableTarget } from "./scalable-target";
+import { Duration } from "../../duration";
+import { AwsConstructBase, AwsConstructProps } from "../aws-construct";
+/**
+ * Properties for a scaling policy
+ */
+export interface StepScalingActionProps extends AwsConstructProps {
+    /**
+     * The scalable target
+     */
+    readonly scalingTarget: IScalableTarget;
+    /**
+     * A name for the scaling policy
+     *
+     * @default - The friendly name of this construct.
+     */
+    readonly policyName?: string;
+    /**
+     * How the adjustment numbers are interpreted
+     *
+     * @default ChangeInCapacity
+     */
+    readonly adjustmentType?: AdjustmentType;
+    /**
+     * Grace period after scaling activity.
+     *
+     * For scale out policies, multiple scale outs during the cooldown period are
+     * squashed so that only the biggest scale out happens.
+     *
+     * For scale in policies, subsequent scale ins during the cooldown period are
+     * ignored.
+     *
+     * @see https://docs.aws.amazon.com/autoscaling/application/APIReference/API_StepScalingPolicyConfiguration.html
+     * @default No cooldown period
+     */
+    readonly cooldown?: Duration;
+    /**
+     * Minimum absolute number to adjust capacity with as result of percentage scaling.
+     *
+     * Only when using AdjustmentType = PercentChangeInCapacity, this number controls
+     * the minimum absolute effect size.
+     *
+     * @default No minimum scaling effect
+     */
+    readonly minAdjustmentMagnitude?: number;
+    /**
+     * The aggregation type for the CloudWatch metrics.
+     *
+     * @default Average
+     */
+    readonly metricAggregationType?: MetricAggregationType;
+}
+/**
+ * Define a step scaling action
+ *
+ * This kind of scaling policy adjusts the target capacity in configurable
+ * steps. The size of the step is configurable based on the metric's distance
+ * to its alarm threshold.
+ *
+ * This Action must be used as the target of a CloudWatch alarm to take effect.
+ */
+export declare class StepScalingAction extends AwsConstructBase {
+    /**
+     * ARN of the scaling policy
+     */
+    readonly scalingPolicyArn: string;
+    private readonly resource;
+    private readonly adjustments;
+    get outputs(): Record<string, any>;
+    constructor(scope: Construct, id: string, props: StepScalingActionProps);
+    /**
+     * Add an adjusment interval to the ScalingAction
+     */
+    addAdjustment(adjustment: AdjustmentTier): void;
+}
+/**
+ * How adjustment numbers are interpreted
+ */
+export declare enum AdjustmentType {
+    /**
+     * Add the adjustment number to the current capacity.
+     *
+     * A positive number increases capacity, a negative number decreases capacity.
+     */
+    CHANGE_IN_CAPACITY = "ChangeInCapacity",
+    /**
+     * Add this percentage of the current capacity to itself.
+     *
+     * The number must be between -100 and 100; a positive number increases
+     * capacity and a negative number decreases it.
+     */
+    PERCENT_CHANGE_IN_CAPACITY = "PercentChangeInCapacity",
+    /**
+     * Make the capacity equal to the exact number given.
+     */
+    EXACT_CAPACITY = "ExactCapacity"
+}
+/**
+ * How the scaling metric is going to be aggregated
+ */
+export declare enum MetricAggregationType {
+    /**
+     * Average
+     */
+    AVERAGE = "Average",
+    /**
+     * Minimum
+     */
+    MINIMUM = "Minimum",
+    /**
+     * Maximum
+     */
+    MAXIMUM = "Maximum"
+}
+/**
+ * An adjustment
+ */
+export interface AdjustmentTier {
+    /**
+     * What number to adjust the capacity with
+     *
+     * The number is interpeted as an added capacity, a new fixed capacity or an
+     * added percentage depending on the AdjustmentType value of the
+     * StepScalingPolicy.
+     *
+     * Can be positive or negative.
+     */
+    readonly adjustment: number;
+    /**
+     * Lower bound where this scaling tier applies.
+     *
+     * The scaling tier applies if the difference between the metric
+     * value and its alarm threshold is higher than this value.
+     *
+     * @default -Infinity if this is the first tier, otherwise the upperBound of the previous tier
+     */
+    readonly lowerBound?: number;
+    /**
+     * Upper bound where this scaling tier applies
+     *
+     * The scaling tier applies if the difference between the metric
+     * value and its alarm threshold is lower than this value.
+     *
+     * @default +Infinity
+     */
+    readonly upperBound?: number;
+}

package/lib/aws/compute/step-scaling-action.js

@@ -0,0 +1,109 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricAggregationType = exports.AdjustmentType = exports.StepScalingAction = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.168.0/packages/aws-cdk-lib/aws-applicationautoscaling/lib/step-scaling-action.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const aws_construct_1 = require("../aws-construct");
+/**
+ * Define a step scaling action
+ *
+ * This kind of scaling policy adjusts the target capacity in configurable
+ * steps. The size of the step is configurable based on the metric's distance
+ * to its alarm threshold.
+ *
+ * This Action must be used as the target of a CloudWatch alarm to take effect.
+ */
+class StepScalingAction extends aws_construct_1.AwsConstructBase {
+    get outputs() {
+        return {
+            scalingPolicyArn: this.scalingPolicyArn,
+        };
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.adjustments = new Array();
+        const policyName = props.policyName ||
+            this.stack.uniqueResourceName(this, {
+                prefix: this.gridUUID,
+            });
+        this.resource = new provider_aws_1.appautoscalingPolicy.AppautoscalingPolicy(this, "Resource", {
+            name: policyName,
+            policyType: "StepScaling",
+            resourceId: props.scalingTarget.resourceId,
+            scalableDimension: props.scalingTarget.scalableDimension,
+            serviceNamespace: props.scalingTarget.serviceNamespace,
+            stepScalingPolicyConfiguration: {
+                adjustmentType: props.adjustmentType ?? AdjustmentType.CHANGE_IN_CAPACITY,
+                cooldown: props.cooldown?.toSeconds(),
+                minAdjustmentMagnitude: props.minAdjustmentMagnitude,
+                metricAggregationType: props.metricAggregationType ?? MetricAggregationType.AVERAGE,
+                stepAdjustment: cdktf_1.Lazy.anyValue({
+                    produce: () => this.adjustments.map(provider_aws_1.appautoscalingPolicy.appautoscalingPolicyStepScalingPolicyConfigurationStepAdjustmentToTerraform),
+                }),
+            },
+        });
+        this.scalingPolicyArn = this.resource.arn;
+    }
+    /**
+     * Add an adjusment interval to the ScalingAction
+     */
+    addAdjustment(adjustment) {
+        if (adjustment.lowerBound === undefined &&
+            adjustment.upperBound === undefined) {
+            throw new Error("At least one of lowerBound or upperBound is required");
+        }
+        this.adjustments.push({
+            metricIntervalLowerBound: adjustment.lowerBound?.toString(),
+            metricIntervalUpperBound: adjustment.upperBound?.toString(),
+            scalingAdjustment: adjustment.adjustment,
+        });
+    }
+}
+exports.StepScalingAction = StepScalingAction;
+_a = JSII_RTTI_SYMBOL_1;
+StepScalingAction[_a] = { fqn: "terraconstructs.aws.compute.StepScalingAction", version: "0.0.24" };
+/**
+ * How adjustment numbers are interpreted
+ */
+var AdjustmentType;
+(function (AdjustmentType) {
+    /**
+     * Add the adjustment number to the current capacity.
+     *
+     * A positive number increases capacity, a negative number decreases capacity.
+     */
+    AdjustmentType["CHANGE_IN_CAPACITY"] = "ChangeInCapacity";
+    /**
+     * Add this percentage of the current capacity to itself.
+     *
+     * The number must be between -100 and 100; a positive number increases
+     * capacity and a negative number decreases it.
+     */
+    AdjustmentType["PERCENT_CHANGE_IN_CAPACITY"] = "PercentChangeInCapacity";
+    /**
+     * Make the capacity equal to the exact number given.
+     */
+    AdjustmentType["EXACT_CAPACITY"] = "ExactCapacity";
+})(AdjustmentType || (exports.AdjustmentType = AdjustmentType = {}));
+/**
+ * How the scaling metric is going to be aggregated
+ */
+var MetricAggregationType;
+(function (MetricAggregationType) {
+    /**
+     * Average
+     */
+    MetricAggregationType["AVERAGE"] = "Average";
+    /**
+     * Minimum
+     */
+    MetricAggregationType["MINIMUM"] = "Minimum";
+    /**
+     * Maximum
+     */
+    MetricAggregationType["MAXIMUM"] = "Maximum";
+})(MetricAggregationType || (exports.MetricAggregationType = MetricAggregationType = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-scaling-action.js","sourceRoot":"","sources":["../../../src/aws/compute/step-scaling-action.ts"],"names":[],"mappings":";;;;;AAAA,0HAA0H;AAE1H,sDAA2D;AAC3D,iCAA6B;AAI7B,oDAAuE;AAyDvE;;;;;;;;GAQG;AACH,MAAa,iBAAkB,SAAQ,gCAAgB;IAUrD,IAAW,OAAO;QAChB,OAAO;YACL,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;SACxC,CAAC;IACJ,CAAC;IAED,YAAY,KAAgB,EAAE,EAAU,EAAE,KAA6B;QACrE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;QAVT,gBAAW,GAC1B,IAAI,KAAK,EAAyF,CAAC;QAUnG,MAAM,UAAU,GACd,KAAK,CAAC,UAAU;YAChB,IAAI,CAAC,KAAK,CAAC,kBAAkB,CAAC,IAAI,EAAE;gBAClC,MAAM,EAAE,IAAI,CAAC,QAAQ;aACtB,CAAC,CAAC;QAEL,IAAI,CAAC,QAAQ,GAAG,IAAI,mCAAoB,CAAC,oBAAoB,CAC3D,IAAI,EACJ,UAAU,EACV;YACE,IAAI,EAAE,UAAU;YAChB,UAAU,EAAE,aAAa;YACzB,UAAU,EAAE,KAAK,CAAC,aAAa,CAAC,UAAU;YAC1C,iBAAiB,EAAE,KAAK,CAAC,aAAa,CAAC,iBAAiB;YACxD,gBAAgB,EAAE,KAAK,CAAC,aAAa,CAAC,gBAAgB;YACtD,8BAA8B,EAAE;gBAC9B,cAAc,EACZ,KAAK,CAAC,cAAc,IAAI,cAAc,CAAC,kBAAkB;gBAC3D,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,SAAS,EAAE;gBACrC,sBAAsB,EAAE,KAAK,CAAC,sBAAsB;gBACpD,qBAAqB,EACnB,KAAK,CAAC,qBAAqB,IAAI,qBAAqB,CAAC,OAAO;gBAC9D,cAAc,EAAE,YAAI,CAAC,QAAQ,CAAC;oBAC5B,OAAO,EAAE,GAAG,EAAE,CACZ,IAAI,CAAC,WAAW,CAAC,GAAG,CAClB,mCAAoB,CAAC,2EAA2E,CACjG;iBACJ,CAAC;aACH;SACF,CACF,CAAC;QAEF,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC;IAC5C,CAAC;IAED;;OAEG;IACI,aAAa,CAAC,UAA0B;QAC7C,IACE,UAAU,CAAC,UAAU,KAAK,SAAS;YACnC,UAAU,CAAC,UAAU,KAAK,SAAS,EACnC,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;QAC1E,CAAC;QACD,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;YACpB,wBAAwB,EAAE,UAAU,CAAC,UAAU,EAAE,QAAQ,EAAE;YAC3D,wBAAwB,EAAE,UAAU,CAAC,UAAU,EAAE,QAAQ,EAAE;YAC3D,iBAAiB,EAAE,UAAU,CAAC,UAAU;SACzC,CAAC,CAAC;IACL,CAAC;;AApEH,8CAqEC;;;AAED;;GAEG;AACH,IAAY,cAoBX;AApBD,WAAY,cAAc;IACxB;;;;OAIG;IACH,yDAAuC,CAAA;IAEvC;;;;;OAKG;IACH,wEAAsD,CAAA;IAEtD;;OAEG;IACH,kDAAgC,CAAA;AAClC,CAAC,EApBW,cAAc,8BAAd,cAAc,QAoBzB;AAED;;GAEG;AACH,IAAY,qBAeX;AAfD,WAAY,qBAAqB;IAC/B;;OAEG;IACH,4CAAmB,CAAA;IAEnB;;OAEG;IACH,4CAAmB,CAAA;IAEnB;;OAEG;IACH,4CAAmB,CAAA;AACrB,CAAC,EAfW,qBAAqB,qCAArB,qBAAqB,QAehC","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.168.0/packages/aws-cdk-lib/aws-applicationautoscaling/lib/step-scaling-action.ts\n\nimport { appautoscalingPolicy } from \"@cdktf/provider-aws\";\nimport { Lazy } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { IScalableTarget } from \"./scalable-target\";\nimport { Duration } from \"../../duration\";\nimport { AwsConstructBase, AwsConstructProps } from \"../aws-construct\";\n\n/**\n * Properties for a scaling policy\n */\nexport interface StepScalingActionProps extends AwsConstructProps {\n  /**\n   * The scalable target\n   */\n  readonly scalingTarget: IScalableTarget;\n\n  /**\n   * A name for the scaling policy\n   *\n   * @default - The friendly name of this construct.\n   */\n  readonly policyName?: string;\n\n  /**\n   * How the adjustment numbers are interpreted\n   *\n   * @default ChangeInCapacity\n   */\n  readonly adjustmentType?: AdjustmentType;\n\n  /**\n   * Grace period after scaling activity.\n   *\n   * For scale out policies, multiple scale outs during the cooldown period are\n   * squashed so that only the biggest scale out happens.\n   *\n   * For scale in policies, subsequent scale ins during the cooldown period are\n   * ignored.\n   *\n   * @see https://docs.aws.amazon.com/autoscaling/application/APIReference/API_StepScalingPolicyConfiguration.html\n   * @default No cooldown period\n   */\n  readonly cooldown?: Duration;\n\n  /**\n   * Minimum absolute number to adjust capacity with as result of percentage scaling.\n   *\n   * Only when using AdjustmentType = PercentChangeInCapacity, this number controls\n   * the minimum absolute effect size.\n   *\n   * @default No minimum scaling effect\n   */\n  readonly minAdjustmentMagnitude?: number;\n\n  /**\n   * The aggregation type for the CloudWatch metrics.\n   *\n   * @default Average\n   */\n  readonly metricAggregationType?: MetricAggregationType;\n}\n\n/**\n * Define a step scaling action\n *\n * This kind of scaling policy adjusts the target capacity in configurable\n * steps. The size of the step is configurable based on the metric's distance\n * to its alarm threshold.\n *\n * This Action must be used as the target of a CloudWatch alarm to take effect.\n */\nexport class StepScalingAction extends AwsConstructBase {\n  /**\n   * ARN of the scaling policy\n   */\n  public readonly scalingPolicyArn: string;\n\n  private readonly resource: appautoscalingPolicy.AppautoscalingPolicy;\n  private readonly adjustments =\n    new Array<appautoscalingPolicy.AppautoscalingPolicyStepScalingPolicyConfigurationStepAdjustment>();\n\n  public get outputs(): Record<string, any> {\n    return {\n      scalingPolicyArn: this.scalingPolicyArn,\n    };\n  }\n\n  constructor(scope: Construct, id: string, props: StepScalingActionProps) {\n    super(scope, id, props);\n    const policyName =\n      props.policyName ||\n      this.stack.uniqueResourceName(this, {\n        prefix: this.gridUUID,\n      });\n\n    this.resource = new appautoscalingPolicy.AppautoscalingPolicy(\n      this,\n      \"Resource\",\n      {\n        name: policyName,\n        policyType: \"StepScaling\",\n        resourceId: props.scalingTarget.resourceId,\n        scalableDimension: props.scalingTarget.scalableDimension,\n        serviceNamespace: props.scalingTarget.serviceNamespace,\n        stepScalingPolicyConfiguration: {\n          adjustmentType:\n            props.adjustmentType ?? AdjustmentType.CHANGE_IN_CAPACITY,\n          cooldown: props.cooldown?.toSeconds(),\n          minAdjustmentMagnitude: props.minAdjustmentMagnitude,\n          metricAggregationType:\n            props.metricAggregationType ?? MetricAggregationType.AVERAGE,\n          stepAdjustment: Lazy.anyValue({\n            produce: () =>\n              this.adjustments.map(\n                appautoscalingPolicy.appautoscalingPolicyStepScalingPolicyConfigurationStepAdjustmentToTerraform,\n              ),\n          }),\n        },\n      },\n    );\n\n    this.scalingPolicyArn = this.resource.arn;\n  }\n\n  /**\n   * Add an adjusment interval to the ScalingAction\n   */\n  public addAdjustment(adjustment: AdjustmentTier) {\n    if (\n      adjustment.lowerBound === undefined &&\n      adjustment.upperBound === undefined\n    ) {\n      throw new Error(\"At least one of lowerBound or upperBound is required\");\n    }\n    this.adjustments.push({\n      metricIntervalLowerBound: adjustment.lowerBound?.toString(),\n      metricIntervalUpperBound: adjustment.upperBound?.toString(),\n      scalingAdjustment: adjustment.adjustment,\n    });\n  }\n}\n\n/**\n * How adjustment numbers are interpreted\n */\nexport enum AdjustmentType {\n  /**\n   * Add the adjustment number to the current capacity.\n   *\n   * A positive number increases capacity, a negative number decreases capacity.\n   */\n  CHANGE_IN_CAPACITY = \"ChangeInCapacity\",\n\n  /**\n   * Add this percentage of the current capacity to itself.\n   *\n   * The number must be between -100 and 100; a positive number increases\n   * capacity and a negative number decreases it.\n   */\n  PERCENT_CHANGE_IN_CAPACITY = \"PercentChangeInCapacity\",\n\n  /**\n   * Make the capacity equal to the exact number given.\n   */\n  EXACT_CAPACITY = \"ExactCapacity\",\n}\n\n/**\n * How the scaling metric is going to be aggregated\n */\nexport enum MetricAggregationType {\n  /**\n   * Average\n   */\n  AVERAGE = \"Average\",\n\n  /**\n   * Minimum\n   */\n  MINIMUM = \"Minimum\",\n\n  /**\n   * Maximum\n   */\n  MAXIMUM = \"Maximum\",\n}\n\n/**\n * An adjustment\n */\nexport interface AdjustmentTier {\n  /**\n   * What number to adjust the capacity with\n   *\n   * The number is interpeted as an added capacity, a new fixed capacity or an\n   * added percentage depending on the AdjustmentType value of the\n   * StepScalingPolicy.\n   *\n   * Can be positive or negative.\n   */\n  readonly adjustment: number;\n\n  /**\n   * Lower bound where this scaling tier applies.\n   *\n   * The scaling tier applies if the difference between the metric\n   * value and its alarm threshold is higher than this value.\n   *\n   * @default -Infinity if this is the first tier, otherwise the upperBound of the previous tier\n   */\n  readonly lowerBound?: number;\n\n  /**\n   * Upper bound where this scaling tier applies\n   *\n   * The scaling tier applies if the difference between the metric\n   * value and its alarm threshold is lower than this value.\n   *\n   * @default +Infinity\n   */\n  readonly upperBound?: number;\n}\n"]}

package/lib/aws/compute/step-scaling-policy.d.ts

@@ -0,0 +1,132 @@
+import { Construct } from "constructs";
+import { IScalableTarget } from "./scalable-target";
+import { AdjustmentType, MetricAggregationType, StepScalingAction } from "./step-scaling-action";
+import { Duration } from "../../duration";
+import * as cloudwatch from "../cloudwatch";
+export interface BasicStepScalingPolicyProps {
+    /**
+     * Metric to scale on.
+     */
+    readonly metric: cloudwatch.IMetric;
+    /**
+     * The intervals for scaling.
+     *
+     * Maps a range of metric values to a particular scaling behavior.
+     *
+     * Must be between 2 and 40 steps.
+     */
+    readonly scalingSteps: ScalingInterval[];
+    /**
+     * How the adjustment numbers inside 'intervals' are interpreted.
+     *
+     * @default ChangeInCapacity
+     */
+    readonly adjustmentType?: AdjustmentType;
+    /**
+     * Grace period after scaling activity.
+     *
+     * Subsequent scale outs during the cooldown period are squashed so that only
+     * the biggest scale out happens.
+     *
+     * Subsequent scale ins during the cooldown period are ignored.
+     *
+     * @see https://docs.aws.amazon.com/autoscaling/application/APIReference/API_StepScalingPolicyConfiguration.html
+     * @default No cooldown period
+     */
+    readonly cooldown?: Duration;
+    /**
+     * Minimum absolute number to adjust capacity with as result of percentage scaling.
+     *
+     * Only when using AdjustmentType = PercentChangeInCapacity, this number controls
+     * the minimum absolute effect size.
+     *
+     * @default No minimum scaling effect
+     */
+    readonly minAdjustmentMagnitude?: number;
+    /**
+     * How many evaluation periods of the metric to wait before triggering a scaling action
+     *
+     * Raising this value can be used to smooth out the metric, at the expense
+     * of slower response times.
+     *
+     * If `datapointsToAlarm` is not set, then all data points in the evaluation period
+     * must meet the criteria to trigger a scaling action.
+     *
+     * @default 1
+     */
+    readonly evaluationPeriods?: number;
+    /**
+     * The number of data points out of the evaluation periods that must be breaching to
+     * trigger a scaling action
+     *
+     * Creates an "M out of N" alarm, where this property is the M and the value set for
+     * `evaluationPeriods` is the N value.
+     *
+     * Only has meaning if `evaluationPeriods != 1`.
+     *
+     * @default - Same as `evaluationPeriods`
+     */
+    readonly datapointsToAlarm?: number;
+    /**
+     * Aggregation to apply to all data points over the evaluation periods
+     *
+     * Only has meaning if `evaluationPeriods != 1`.
+     *
+     * @default - The statistic from the metric if applicable (MIN, MAX, AVERAGE), otherwise AVERAGE.
+     */
+    readonly metricAggregationType?: MetricAggregationType;
+}
+export interface StepScalingPolicyProps extends BasicStepScalingPolicyProps {
+    /**
+     * The scaling target
+     */
+    readonly scalingTarget: IScalableTarget;
+}
+/**
+ * Define a scaling strategy which scales depending on absolute values of some metric.
+ *
+ * You can specify the scaling behavior for various values of the metric.
+ *
+ * Implemented using one or more CloudWatch alarms and Step Scaling Policies.
+ */
+export declare class StepScalingPolicy extends Construct {
+    readonly lowerAlarm?: cloudwatch.Alarm;
+    readonly lowerAction?: StepScalingAction;
+    readonly upperAlarm?: cloudwatch.Alarm;
+    readonly upperAction?: StepScalingAction;
+    constructor(scope: Construct, id: string, props: StepScalingPolicyProps);
+}
+/**
+ * A range of metric values in which to apply a certain scaling operation
+ */
+export interface ScalingInterval {
+    /**
+     * The lower bound of the interval.
+     *
+     * The scaling adjustment will be applied if the metric is higher than this value.
+     *
+     * @default Threshold automatically derived from neighbouring intervals
+     */
+    readonly lower?: number;
+    /**
+     * The upper bound of the interval.
+     *
+     * The scaling adjustment will be applied if the metric is lower than this value.
+     *
+     * @default Threshold automatically derived from neighbouring intervals
+     */
+    readonly upper?: number;
+    /**
+     * The capacity adjustment to apply in this interval
+     *
+     * The number is interpreted differently based on AdjustmentType:
+     *
+     * - ChangeInCapacity: add the adjustment to the current capacity.
+     *  The number can be positive or negative.
+     * - PercentChangeInCapacity: add or remove the given percentage of the current
+     *   capacity to itself. The number can be in the range [-100..100].
+     * - ExactCapacity: set the capacity to this number. The number must
+     *   be positive.
+     */
+    readonly change: number;
+}

package/lib/aws/compute/step-scaling-policy.js

@@ -0,0 +1,153 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StepScalingPolicy = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/aws-applicationautoscaling/lib/step-scaling-policy.ts
+const cdktf_1 = require("cdktf");
+const constructs_1 = require("constructs");
+const interval_utils_1 = require("./autoscaling-common/interval-utils");
+const step_scaling_action_1 = require("./step-scaling-action");
+const cloudwatch = require("../cloudwatch");
+/**
+ * Define a scaling strategy which scales depending on absolute values of some metric.
+ *
+ * You can specify the scaling behavior for various values of the metric.
+ *
+ * Implemented using one or more CloudWatch alarms and Step Scaling Policies.
+ */
+class StepScalingPolicy extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        if (props.scalingSteps.length < 2) {
+            // throw new ValidationError(
+            throw new Error("You must supply at least 2 intervals for autoscaling");
+        }
+        if (props.scalingSteps.length > 40) {
+            // throw new ValidationError(
+            throw new Error(`'scalingSteps' can have at most 40 steps, got ${props.scalingSteps.length}`);
+        }
+        if (props.evaluationPeriods !== undefined &&
+            !cdktf_1.Token.isUnresolved(props.evaluationPeriods) &&
+            props.evaluationPeriods < 1) {
+            // throw new ValidationError(
+            throw new Error(`evaluationPeriods cannot be less than 1, got: ${props.evaluationPeriods}`);
+        }
+        if (props.datapointsToAlarm !== undefined) {
+            if (props.evaluationPeriods === undefined) {
+                // throw new ValidationError(
+                throw new Error("evaluationPeriods must be set if datapointsToAlarm is set");
+            }
+            if (!cdktf_1.Token.isUnresolved(props.datapointsToAlarm) &&
+                props.datapointsToAlarm < 1) {
+                // throw new ValidationError(
+                throw new Error(`datapointsToAlarm cannot be less than 1, got: ${props.datapointsToAlarm}`);
+            }
+            if (!cdktf_1.Token.isUnresolved(props.datapointsToAlarm) &&
+                !cdktf_1.Token.isUnresolved(props.evaluationPeriods) &&
+                props.evaluationPeriods < props.datapointsToAlarm) {
+                // throw new ValidationError(
+                throw new Error(`datapointsToAlarm must be less than or equal to evaluationPeriods, got datapointsToAlarm: ${props.datapointsToAlarm}, evaluationPeriods: ${props.evaluationPeriods}`);
+            }
+        }
+        const adjustmentType = props.adjustmentType || step_scaling_action_1.AdjustmentType.CHANGE_IN_CAPACITY;
+        const changesAreAbsolute = adjustmentType === step_scaling_action_1.AdjustmentType.EXACT_CAPACITY;
+        const intervals = (0, interval_utils_1.normalizeIntervals)(props.scalingSteps, changesAreAbsolute);
+        const alarms = (0, interval_utils_1.findAlarmThresholds)(intervals);
+        if (alarms.lowerAlarmIntervalIndex !== undefined) {
+            const threshold = intervals[alarms.lowerAlarmIntervalIndex].upper;
+            this.lowerAction = new step_scaling_action_1.StepScalingAction(this, "LowerPolicy", {
+                adjustmentType,
+                cooldown: props.cooldown,
+                metricAggregationType: props.metricAggregationType ??
+                    aggregationTypeFromMetric(props.metric),
+                minAdjustmentMagnitude: props.minAdjustmentMagnitude,
+                scalingTarget: props.scalingTarget,
+            });
+            for (let i = alarms.lowerAlarmIntervalIndex; i >= 0; i--) {
+                this.lowerAction.addAdjustment({
+                    adjustment: intervals[i].change,
+                    lowerBound: i !== 0 ? intervals[i].lower - threshold : undefined, // Extend last interval to -infinity
+                    upperBound: intervals[i].upper - threshold,
+                });
+            }
+            this.lowerAlarm = new cloudwatch.Alarm(this, "LowerAlarm", {
+                // Recommended by AutoScaling
+                metric: props.metric,
+                alarmDescription: "Lower threshold scaling alarm",
+                comparisonOperator: cloudwatch.ComparisonOperator.LESS_THAN_OR_EQUAL_TO_THRESHOLD,
+                evaluationPeriods: props.evaluationPeriods ?? 1,
+                datapointsToAlarm: props.datapointsToAlarm,
+                threshold,
+            });
+            this.lowerAlarm.addAlarmAction(new StepScalingAlarmAction(this.lowerAction));
+        }
+        if (alarms.upperAlarmIntervalIndex !== undefined) {
+            const threshold = intervals[alarms.upperAlarmIntervalIndex].lower;
+            this.upperAction = new step_scaling_action_1.StepScalingAction(this, "UpperPolicy", {
+                adjustmentType,
+                cooldown: props.cooldown,
+                metricAggregationType: props.metricAggregationType ??
+                    aggregationTypeFromMetric(props.metric),
+                minAdjustmentMagnitude: props.minAdjustmentMagnitude,
+                scalingTarget: props.scalingTarget,
+            });
+            for (let i = alarms.upperAlarmIntervalIndex; i < intervals.length; i++) {
+                this.upperAction.addAdjustment({
+                    adjustment: intervals[i].change,
+                    lowerBound: intervals[i].lower - threshold,
+                    upperBound: i !== intervals.length - 1
+                        ? intervals[i].upper - threshold
+                        : undefined, // Extend last interval to +infinity
+                });
+            }
+            this.upperAlarm = new cloudwatch.Alarm(this, "UpperAlarm", {
+                // Recommended by AutoScaling
+                metric: props.metric,
+                alarmDescription: "Upper threshold scaling alarm",
+                comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+                evaluationPeriods: props.evaluationPeriods ?? 1,
+                datapointsToAlarm: props.datapointsToAlarm,
+                threshold,
+            });
+            this.upperAlarm.addAlarmAction(new StepScalingAlarmAction(this.upperAction));
+        }
+    }
+}
+exports.StepScalingPolicy = StepScalingPolicy;
+_a = JSII_RTTI_SYMBOL_1;
+StepScalingPolicy[_a] = { fqn: "terraconstructs.aws.compute.StepScalingPolicy", version: "0.0.24" };
+function aggregationTypeFromMetric(metric) {
+    const statistic = metric.toMetricConfig().metricStat?.statistic;
+    if (statistic == null) {
+        return undefined;
+    } // Math expression, don't know aggregation, leave default
+    switch (statistic) {
+        case "Average":
+            return step_scaling_action_1.MetricAggregationType.AVERAGE;
+        case "Minimum":
+            return step_scaling_action_1.MetricAggregationType.MINIMUM;
+        case "Maximum":
+            return step_scaling_action_1.MetricAggregationType.MAXIMUM;
+        default:
+            return step_scaling_action_1.MetricAggregationType.AVERAGE;
+    }
+}
+/**
+ * Use a StepScalingAction as an Alarm Action
+ *
+ * This class is here and not in aws-cloudwatch-actions because this library
+ * needs to use the class, and otherwise we'd have a circular dependency:
+ *
+ * aws-autoscaling -> aws-cloudwatch-actions (for using the Action)
+ * aws-cloudwatch-actions -> aws-autoscaling (for the definition of IStepScalingAction)
+ */
+class StepScalingAlarmAction {
+    constructor(stepScalingAction) {
+        this.stepScalingAction = stepScalingAction;
+    }
+    bind(_scope, _alarm) {
+        return { alarmActionArn: this.stepScalingAction.scalingPolicyArn };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-scaling-policy.js","sourceRoot":"","sources":["../../../src/aws/compute/step-scaling-policy.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/aws-applicationautoscaling/lib/step-scaling-policy.ts\n\nimport { Token } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport {\n  findAlarmThresholds,\n  normalizeIntervals,\n} from \"./autoscaling-common/interval-utils\";\nimport { IScalableTarget } from \"./scalable-target\";\nimport {\n  AdjustmentType,\n  MetricAggregationType,\n  StepScalingAction,\n} from \"./step-scaling-action\";\nimport { Duration } from \"../../duration\";\nimport * as cloudwatch from \"../cloudwatch\";\n// TODO Adupt ValidationError is available, otherwise use standard Error\n// - https://github.com/aws/aws-cdk/pull/33382/\n// - https://github.com/aws/aws-cdk/pull/33045\n// import { ValidationError } from \"../../errors\";\n\nexport interface BasicStepScalingPolicyProps {\n  /**\n   * Metric to scale on.\n   */\n  readonly metric: cloudwatch.IMetric;\n\n  /**\n   * The intervals for scaling.\n   *\n   * Maps a range of metric values to a particular scaling behavior.\n   *\n   * Must be between 2 and 40 steps.\n   */\n  readonly scalingSteps: ScalingInterval[];\n\n  /**\n   * How the adjustment numbers inside 'intervals' are interpreted.\n   *\n   * @default ChangeInCapacity\n   */\n  readonly adjustmentType?: AdjustmentType;\n\n  /**\n   * Grace period after scaling activity.\n   *\n   * Subsequent scale outs during the cooldown period are squashed so that only\n   * the biggest scale out happens.\n   *\n   * Subsequent scale ins during the cooldown period are ignored.\n   *\n   * @see https://docs.aws.amazon.com/autoscaling/application/APIReference/API_StepScalingPolicyConfiguration.html\n   * @default No cooldown period\n   */\n  readonly cooldown?: Duration;\n\n  /**\n   * Minimum absolute number to adjust capacity with as result of percentage scaling.\n   *\n   * Only when using AdjustmentType = PercentChangeInCapacity, this number controls\n   * the minimum absolute effect size.\n   *\n   * @default No minimum scaling effect\n   */\n  readonly minAdjustmentMagnitude?: number;\n\n  /**\n   * How many evaluation periods of the metric to wait before triggering a scaling action\n   *\n   * Raising this value can be used to smooth out the metric, at the expense\n   * of slower response times.\n   *\n   * If `datapointsToAlarm` is not set, then all data points in the evaluation period\n   * must meet the criteria to trigger a scaling action.\n   *\n   * @default 1\n   */\n  readonly evaluationPeriods?: number;\n\n  /**\n   * The number of data points out of the evaluation periods that must be breaching to\n   * trigger a scaling action\n   *\n   * Creates an \"M out of N\" alarm, where this property is the M and the value set for\n   * `evaluationPeriods` is the N value.\n   *\n   * Only has meaning if `evaluationPeriods != 1`.\n   *\n   * @default - Same as `evaluationPeriods`\n   */\n  readonly datapointsToAlarm?: number;\n\n  /**\n   * Aggregation to apply to all data points over the evaluation periods\n   *\n   * Only has meaning if `evaluationPeriods != 1`.\n   *\n   * @default - The statistic from the metric if applicable (MIN, MAX, AVERAGE), otherwise AVERAGE.\n   */\n  readonly metricAggregationType?: MetricAggregationType;\n}\n\nexport interface StepScalingPolicyProps extends BasicStepScalingPolicyProps {\n  /**\n   * The scaling target\n   */\n  readonly scalingTarget: IScalableTarget;\n}\n\n/**\n * Define a scaling strategy which scales depending on absolute values of some metric.\n *\n * You can specify the scaling behavior for various values of the metric.\n *\n * Implemented using one or more CloudWatch alarms and Step Scaling Policies.\n */\nexport class StepScalingPolicy extends Construct {\n  public readonly lowerAlarm?: cloudwatch.Alarm;\n  public readonly lowerAction?: StepScalingAction;\n  public readonly upperAlarm?: cloudwatch.Alarm;\n  public readonly upperAction?: StepScalingAction;\n\n  constructor(scope: Construct, id: string, props: StepScalingPolicyProps) {\n    super(scope, id);\n\n    if (props.scalingSteps.length < 2) {\n      // throw new ValidationError(\n      throw new Error(\n        \"You must supply at least 2 intervals for autoscaling\",\n        // scope,\n      );\n    }\n\n    if (props.scalingSteps.length > 40) {\n      // throw new ValidationError(\n      throw new Error(\n        `'scalingSteps' can have at most 40 steps, got ${props.scalingSteps.length}`,\n        // scope,\n      );\n    }\n\n    if (\n      props.evaluationPeriods !== undefined &&\n      !Token.isUnresolved(props.evaluationPeriods) &&\n      props.evaluationPeriods < 1\n    ) {\n      // throw new ValidationError(\n      throw new Error(\n        `evaluationPeriods cannot be less than 1, got: ${props.evaluationPeriods}`,\n        // scope,\n      );\n    }\n    if (props.datapointsToAlarm !== undefined) {\n      if (props.evaluationPeriods === undefined) {\n        // throw new ValidationError(\n        throw new Error(\n          \"evaluationPeriods must be set if datapointsToAlarm is set\",\n          // scope,\n        );\n      }\n      if (\n        !Token.isUnresolved(props.datapointsToAlarm) &&\n        props.datapointsToAlarm < 1\n      ) {\n        // throw new ValidationError(\n        throw new Error(\n          `datapointsToAlarm cannot be less than 1, got: ${props.datapointsToAlarm}`,\n          // scope,\n        );\n      }\n      if (\n        !Token.isUnresolved(props.datapointsToAlarm) &&\n        !Token.isUnresolved(props.evaluationPeriods) &&\n        props.evaluationPeriods < props.datapointsToAlarm\n      ) {\n        // throw new ValidationError(\n        throw new Error(\n          `datapointsToAlarm must be less than or equal to evaluationPeriods, got datapointsToAlarm: ${props.datapointsToAlarm}, evaluationPeriods: ${props.evaluationPeriods}`,\n          // scope,\n        );\n      }\n    }\n\n    const adjustmentType =\n      props.adjustmentType || AdjustmentType.CHANGE_IN_CAPACITY;\n    const changesAreAbsolute = adjustmentType === AdjustmentType.EXACT_CAPACITY;\n\n    const intervals = normalizeIntervals(\n      props.scalingSteps,\n      changesAreAbsolute,\n    );\n    const alarms = findAlarmThresholds(intervals);\n\n    if (alarms.lowerAlarmIntervalIndex !== undefined) {\n      const threshold = intervals[alarms.lowerAlarmIntervalIndex].upper;\n\n      this.lowerAction = new StepScalingAction(this, \"LowerPolicy\", {\n        adjustmentType,\n        cooldown: props.cooldown,\n        metricAggregationType:\n          props.metricAggregationType ??\n          aggregationTypeFromMetric(props.metric),\n        minAdjustmentMagnitude: props.minAdjustmentMagnitude,\n        scalingTarget: props.scalingTarget,\n      });\n\n      for (let i = alarms.lowerAlarmIntervalIndex; i >= 0; i--) {\n        this.lowerAction.addAdjustment({\n          adjustment: intervals[i].change!,\n          lowerBound: i !== 0 ? intervals[i].lower - threshold : undefined, // Extend last interval to -infinity\n          upperBound: intervals[i].upper - threshold,\n        });\n      }\n\n      this.lowerAlarm = new cloudwatch.Alarm(this, \"LowerAlarm\", {\n        // Recommended by AutoScaling\n        metric: props.metric,\n        alarmDescription: \"Lower threshold scaling alarm\",\n        comparisonOperator:\n          cloudwatch.ComparisonOperator.LESS_THAN_OR_EQUAL_TO_THRESHOLD,\n        evaluationPeriods: props.evaluationPeriods ?? 1,\n        datapointsToAlarm: props.datapointsToAlarm,\n        threshold,\n      });\n      this.lowerAlarm.addAlarmAction(\n        new StepScalingAlarmAction(this.lowerAction),\n      );\n    }\n\n    if (alarms.upperAlarmIntervalIndex !== undefined) {\n      const threshold = intervals[alarms.upperAlarmIntervalIndex].lower;\n\n      this.upperAction = new StepScalingAction(this, \"UpperPolicy\", {\n        adjustmentType,\n        cooldown: props.cooldown,\n        metricAggregationType:\n          props.metricAggregationType ??\n          aggregationTypeFromMetric(props.metric),\n        minAdjustmentMagnitude: props.minAdjustmentMagnitude,\n        scalingTarget: props.scalingTarget,\n      });\n\n      for (let i = alarms.upperAlarmIntervalIndex; i < intervals.length; i++) {\n        this.upperAction.addAdjustment({\n          adjustment: intervals[i].change!,\n          lowerBound: intervals[i].lower - threshold,\n          upperBound:\n            i !== intervals.length - 1\n              ? intervals[i].upper - threshold\n              : undefined, // Extend last interval to +infinity\n        });\n      }\n\n      this.upperAlarm = new cloudwatch.Alarm(this, \"UpperAlarm\", {\n        // Recommended by AutoScaling\n        metric: props.metric,\n        alarmDescription: \"Upper threshold scaling alarm\",\n        comparisonOperator:\n          cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n        evaluationPeriods: props.evaluationPeriods ?? 1,\n        datapointsToAlarm: props.datapointsToAlarm,\n        threshold,\n      });\n      this.upperAlarm.addAlarmAction(\n        new StepScalingAlarmAction(this.upperAction),\n      );\n    }\n  }\n}\n\n/**\n * A range of metric values in which to apply a certain scaling operation\n */\nexport interface ScalingInterval {\n  /**\n   * The lower bound of the interval.\n   *\n   * The scaling adjustment will be applied if the metric is higher than this value.\n   *\n   * @default Threshold automatically derived from neighbouring intervals\n   */\n  readonly lower?: number;\n\n  /**\n   * The upper bound of the interval.\n   *\n   * The scaling adjustment will be applied if the metric is lower than this value.\n   *\n   * @default Threshold automatically derived from neighbouring intervals\n   */\n  readonly upper?: number;\n\n  /**\n   * The capacity adjustment to apply in this interval\n   *\n   * The number is interpreted differently based on AdjustmentType:\n   *\n   * - ChangeInCapacity: add the adjustment to the current capacity.\n   *  The number can be positive or negative.\n   * - PercentChangeInCapacity: add or remove the given percentage of the current\n   *   capacity to itself. The number can be in the range [-100..100].\n   * - ExactCapacity: set the capacity to this number. The number must\n   *   be positive.\n   */\n  readonly change: number;\n}\n\nfunction aggregationTypeFromMetric(\n  metric: cloudwatch.IMetric,\n): MetricAggregationType | undefined {\n  const statistic = metric.toMetricConfig().metricStat?.statistic;\n  if (statistic == null) {\n    return undefined;\n  } // Math expression, don't know aggregation, leave default\n\n  switch (statistic) {\n    case \"Average\":\n      return MetricAggregationType.AVERAGE;\n    case \"Minimum\":\n      return MetricAggregationType.MINIMUM;\n    case \"Maximum\":\n      return MetricAggregationType.MAXIMUM;\n    default:\n      return MetricAggregationType.AVERAGE;\n  }\n}\n\n/**\n * Use a StepScalingAction as an Alarm Action\n *\n * This class is here and not in aws-cloudwatch-actions because this library\n * needs to use the class, and otherwise we'd have a circular dependency:\n *\n * aws-autoscaling -> aws-cloudwatch-actions (for using the Action)\n * aws-cloudwatch-actions -> aws-autoscaling (for the definition of IStepScalingAction)\n */\nclass StepScalingAlarmAction implements cloudwatch.IAlarmAction {\n  constructor(private readonly stepScalingAction: StepScalingAction) {}\n\n  public bind(\n    _scope: Construct,\n    _alarm: cloudwatch.IAlarm,\n  ): cloudwatch.AlarmActionConfig {\n    return { alarmActionArn: this.stepScalingAction.scalingPolicyArn };\n  }\n}\n"]}

package/lib/aws/compute/subnet-v2.js

@@ -26,7 +26,7 @@ class IpCidr {
 }
 exports.IpCidr = IpCidr;
 _a = JSII_RTTI_SYMBOL_1;
-IpCidr[_a] = { fqn: "terraconstructs.aws.compute.alpha.IpCidr", version: "0.0.22" };
+IpCidr[_a] = { fqn: "terraconstructs.aws.compute.alpha.IpCidr", version: "0.0.24" };
 /**
  * Name tag constant
  */
@@ -247,7 +247,7 @@ class SubnetV2 extends aws_construct_1.AwsConstructBase {
 }
 exports.SubnetV2 = SubnetV2;
 _b = JSII_RTTI_SYMBOL_1;
-SubnetV2[_b] = { fqn: "terraconstructs.aws.compute.alpha.SubnetV2", version: "0.0.22" };
+SubnetV2[_b] = { fqn: "terraconstructs.aws.compute.alpha.SubnetV2", version: "0.0.24" };
 const subnetTypeMap = {
     [vpc_1.SubnetType.PRIVATE_ISOLATED]: (vpc, subnet) => vpc.isolatedSubnets.push(subnet),
     [vpc_1.SubnetType.PUBLIC]: (vpc, subnet) => vpc.publicSubnets.push(subnet),

package/lib/aws/compute/subnet.js

@@ -58,7 +58,7 @@ class SubnetFilter {
 }
 exports.SubnetFilter = SubnetFilter;
 _a = JSII_RTTI_SYMBOL_1;
-SubnetFilter[_a] = { fqn: "terraconstructs.aws.compute.SubnetFilter", version: "0.0.22" };
+SubnetFilter[_a] = { fqn: "terraconstructs.aws.compute.SubnetFilter", version: "0.0.24" };
 /**
  * Chooses subnets which are in one of the given availability zones.
  */