Resource: awsAutoscalingPolicy

Provides an AutoScaling Scaling Policy resource.

\~> NOTE: You may want to omit desiredCapacity attribute from attached awsAutoscalingGroup when using autoscaling policies. It's good practice to pick either manual or dynamic (policy-based) scaling.

Hands-on: Try the Manage AWS Auto Scaling Groups tutorial on HashiCorp Learn.

Example Usage

/*Provider bindings are generated by running cdktf get.
See https://cdk.tf/provider-generation for more details.*/
import * as aws from "./.gen/providers/aws";
const awsAutoscalingGroupBar = new aws.autoscalingGroup.AutoscalingGroup(
  this,
  "bar",
  {
    availabilityZones: ["us-east-1a"],
    forceDelete: true,
    healthCheckGracePeriod: 300,
    healthCheckType: "ELB",
    launchConfiguration: "${aws_launch_configuration.foo.name}",
    maxSize: 5,
    minSize: 2,
    name: "foobar3-terraform-test",
  }
);
new aws.autoscalingPolicy.AutoscalingPolicy(this, "bat", {
  adjustmentType: "ChangeInCapacity",
  autoscalingGroupName: awsAutoscalingGroupBar.name,
  cooldown: 300,
  name: "foobar3-terraform-test",
  scalingAdjustment: 4,
});

Create target tarcking scaling policy using metric math

/*Provider bindings are generated by running cdktf get.
See https://cdk.tf/provider-generation for more details.*/
import * as aws from "./.gen/providers/aws";
new aws.autoscalingPolicy.AutoscalingPolicy(this, "example", {
  autoscalingGroupName: "my-test-asg",
  name: "foo",
  policyType: "TargetTrackingScaling",
  targetTrackingConfiguration: {
    customizedMetricSpecification: {
      metrics: [
        {
          id: "m1",
          label:
            "Get the queue size (the number of messages waiting to be processed)",
          metricStat: {
            metric: {
              dimensions: [
                {
                  name: "QueueName",
                  value: "my-queue",
                },
              ],
              metricName: "ApproximateNumberOfMessagesVisible",
              namespace: "AWS/SQS",
            },
            stat: "Sum",
          },
          returnData: false,
        },
        {
          id: "m2",
          label: "Get the group size (the number of InService instances)",
          metricStat: {
            metric: {
              dimensions: [
                {
                  name: "AutoScalingGroupName",
                  value: "my-asg",
                },
              ],
              metricName: "GroupInServiceInstances",
              namespace: "AWS/AutoScaling",
            },
            stat: "Average",
          },
          returnData: false,
        },
        {
          expression: "m1 / m2",
          id: "e1",
          label: "Calculate the backlog per instance",
          returnData: true,
        },
      ],
    },
    targetValue: 100,
  },
});

Create predictive scaling policy using customized metrics

/*Provider bindings are generated by running cdktf get.
See https://cdk.tf/provider-generation for more details.*/
import * as aws from "./.gen/providers/aws";
new aws.autoscalingPolicy.AutoscalingPolicy(this, "example", {
  autoscalingGroupName: "my-test-asg",
  name: "foo",
  policyType: "PredictiveScaling",
  predictiveScalingConfiguration: {
    metricSpecification: {
      customizedCapacityMetricSpecification: {
        metricDataQueries: [
          {
            expression:
              "SUM(SEARCH('{AWS/AutoScaling,AutoScalingGroupName} MetricName=\"GroupInServiceIntances\" my-test-asg', 'Average', 300))",
            id: "capacity_sum",
          },
        ],
      },
      customizedLoadMetricSpecification: {
        metricDataQueries: [
          {
            expression:
              "SUM(SEARCH('{AWS/EC2,AutoScalingGroupName} MetricName=\"CPUUtilization\" my-test-asg', 'Sum', 3600))",
            id: "load_sum",
          },
        ],
      },
      customizedScalingMetricSpecification: {
        metricDataQueries: [
          {
            expression:
              "SUM(SEARCH('{AWS/AutoScaling,AutoScalingGroupName} MetricName=\"GroupInServiceIntances\" my-test-asg', 'Average', 300))",
            id: "capacity_sum",
            returnData: false,
          },
          {
            expression:
              "SUM(SEARCH('{AWS/EC2,AutoScalingGroupName} MetricName=\"CPUUtilization\" my-test-asg', 'Sum', 300))",
            id: "load_sum",
            returnData: false,
          },
          {
            expression: "load_sum / (capacity_sum * PERIOD(capacity_sum) / 60)",
            id: "weighted_average",
          },
        ],
      },
      targetValue: 10,
    },
  },
});

Create predictive scaling policy using customized scaling and predefined load metric

/*Provider bindings are generated by running cdktf get.
See https://cdk.tf/provider-generation for more details.*/
import * as aws from "./.gen/providers/aws";
new aws.autoscalingPolicy.AutoscalingPolicy(this, "example", {
  autoscalingGroupName: "my-test-asg",
  name: "foo",
  policyType: "PredictiveScaling",
  predictiveScalingConfiguration: {
    metricSpecification: {
      customizedScalingMetricSpecification: {
        metricDataQueries: [
          {
            id: "scaling",
            metricStat: {
              metric: {
                dimensions: [
                  {
                    name: "AutoScalingGroupName",
                    value: "my-test-asg",
                  },
                ],
                metricName: "CPUUtilization",
                namespace: "AWS/EC2",
              },
              stat: "Average",
            },
          },
        ],
      },
      predefinedLoadMetricSpecification: {
        predefinedMetricType: "ASGTotalCPUUtilization",
        resourceLabel: "testLabel",
      },
      targetValue: 10,
    },
  },
});

Argument Reference

name - (Required) Name of the policy.
autoscalingGroupName - (Required) Name of the autoscaling group.
adjustmentType - (Optional) Whether the adjustment is an absolute number or a percentage of the current capacity. Valid values are changeInCapacity, exactCapacity, and percentChangeInCapacity.
policyType - (Optional) Policy type, either "SimpleScaling", "StepScaling", "TargetTrackingScaling", or "PredictiveScaling". If this value isn't provided, AWS will default to "SimpleScaling."
predictiveScalingConfiguration - (Optional) Predictive scaling policy configuration to use with Amazon EC2 Auto Scaling.
estimatedInstanceWarmup - (Optional) Estimated time, in seconds, until a newly launched instance will contribute CloudWatch metrics. Without a value, AWS will default to the group's specified cooldown period.
enabled - (Optional) Whether the scaling policy is enabled or disabled. Default: true.

The following argument is only available to "SimpleScaling" and "StepScaling" type policies:

minAdjustmentMagnitude - (Optional) Minimum value to scale by when adjustmentType is set to percentChangeInCapacity.

The following arguments are only available to "SimpleScaling" type policies:

cooldown - (Optional) Amount of time, in seconds, after a scaling activity completes and before the next scaling activity can start.
scalingAdjustment - (Optional) Number of instances by which to scale. adjustmentType determines the interpretation of this number (e.g., as an absolute number or as a percentage of the existing Auto Scaling group size). A positive increment adds to the current capacity and a negative value removes from the current capacity.

The following arguments are only available to "StepScaling" type policies:

metricAggregationType - (Optional) Aggregation type for the policy's metrics. Valid values are "Minimum", "Maximum", and "Average". Without a value, AWS will treat the aggregation type as "Average".
stepAdjustment - (Optional) Set of adjustments that manage group scaling. These have the following structure:

/*Provider bindings are generated by running cdktf get.
See https://cdk.tf/provider-generation for more details.*/
import * as aws from "./.gen/providers/aws";
new aws.autoscalingPolicy.AutoscalingPolicy(this, "example", {
  stepAdjustment: [
    {
      metricIntervalLowerBound: 1,
      metricIntervalUpperBound: 2,
      scalingAdjustment: -1,
    },
    {
      metricIntervalLowerBound: 2,
      metricIntervalUpperBound: 3,
      scalingAdjustment: 1,
    },
  ],
});

The following fields are available in step adjustments:

scalingAdjustment - (Required) Number of members by which to scale, when the adjustment bounds are breached. A positive value scales up. A negative value scales down.
metricIntervalLowerBound - (Optional) Lower bound for the difference between the alarm threshold and the CloudWatch metric. Without a value, AWS will treat this bound as negative infinity.
metricIntervalUpperBound - (Optional) Upper bound for the difference between the alarm threshold and the CloudWatch metric. Without a value, AWS will treat this bound as positive infinity. The upper bound must be greater than the lower bound.

Notice the bounds are relative to the alarm threshold, meaning that the starting point is not 0%, but the alarm threshold. Check the official docs for a detailed example.

The following arguments are only available to "TargetTrackingScaling" type policies:

targetTrackingConfiguration - (Optional) Target tracking policy. These have the following structure:

/*Provider bindings are generated by running cdktf get.
See https://cdk.tf/provider-generation for more details.*/
import * as aws from "./.gen/providers/aws";
new aws.autoscalingPolicy.AutoscalingPolicy(this, "example", {
  targetTrackingConfiguration: {
    predefinedMetricSpecification: {
      predefinedMetricType: "ASGAverageCPUUtilization",
    },
    targetValue: 40,
  },
});

The following fields are available in target tracking configuration:

predefinedMetricSpecification - (Optional) Predefined metric. Conflicts with customizedMetricSpecification.
customizedMetricSpecification - (Optional) Customized metric. Conflicts with predefinedMetricSpecification.
targetValue - (Required) Target value for the metric.
disableScaleIn - (Optional, Default: false) Whether scale in by the target tracking policy is disabled.