pulumi-aws-kotlin/com.pulumi.aws.autoscaling.kotlin/PolicyArgs

PolicyArgs

data class PolicyArgs(val adjustmentType: Output<String>? = null, val autoscalingGroupName: Output<String>? = null, val cooldown: Output<Int>? = null, val enabled: Output<Boolean>? = null, val estimatedInstanceWarmup: Output<Int>? = null, val metricAggregationType: Output<String>? = null, val minAdjustmentMagnitude: Output<Int>? = null, val name: Output<String>? = null, val policyType: Output<String>? = null, val predictiveScalingConfiguration: Output<PolicyPredictiveScalingConfigurationArgs>? = null, val scalingAdjustment: Output<Int>? = null, val stepAdjustments: Output<List<PolicyStepAdjustmentArgs>>? = null, val targetTrackingConfiguration: Output<PolicyTargetTrackingConfigurationArgs>? = null) : ConvertibleToJava<PolicyArgs>

Provides an AutoScaling Scaling Policy resource.

NOTE: You may want to omit desired_capacity attribute from attached aws.autoscaling.Group when using autoscaling policies. It's good practice to pick either manual or dynamic (policy-based) scaling.

Example Usage

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.autoscaling.Group;
import com.pulumi.aws.autoscaling.GroupArgs;
import com.pulumi.aws.autoscaling.Policy;
import com.pulumi.aws.autoscaling.PolicyArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var bar = new Group("bar", GroupArgs.builder()
            .availabilityZones("us-east-1a")
            .maxSize(5)
            .minSize(2)
            .healthCheckGracePeriod(300)
            .healthCheckType("ELB")
            .forceDelete(true)
            .launchConfiguration(aws_launch_configuration.foo().name())
            .build());
        var bat = new Policy("bat", PolicyArgs.builder()
            .scalingAdjustment(4)
            .adjustmentType("ChangeInCapacity")
            .cooldown(300)
            .autoscalingGroupName(bar.name())
            .build());
    }
}

Create target tracking scaling policy using metric math

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.autoscaling.Policy;
import com.pulumi.aws.autoscaling.PolicyArgs;
import com.pulumi.aws.autoscaling.inputs.PolicyTargetTrackingConfigurationArgs;
import com.pulumi.aws.autoscaling.inputs.PolicyTargetTrackingConfigurationCustomizedMetricSpecificationArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var example = new Policy("example", PolicyArgs.builder()
            .autoscalingGroupName("my-test-asg")
            .policyType("TargetTrackingScaling")
            .targetTrackingConfiguration(PolicyTargetTrackingConfigurationArgs.builder()
                .customizedMetricSpecification(PolicyTargetTrackingConfigurationCustomizedMetricSpecificationArgs.builder()
                    .metrics(
                        PolicyTargetTrackingConfigurationCustomizedMetricSpecificationMetricArgs.builder()
                            .id("m1")
                            .label("Get the queue size (the number of messages waiting to be processed)")
                            .metricStat(PolicyTargetTrackingConfigurationCustomizedMetricSpecificationMetricMetricStatArgs.builder()
                                .metric(PolicyTargetTrackingConfigurationCustomizedMetricSpecificationMetricMetricStatMetricArgs.builder()
                                    .dimensions(PolicyTargetTrackingConfigurationCustomizedMetricSpecificationMetricMetricStatMetricDimensionArgs.builder()
                                        .name("QueueName")
                                        .value("my-queue")
                                        .build())
                                    .metricName("ApproximateNumberOfMessagesVisible")
                                    .namespace("AWS/SQS")
                                    .build())
                                .stat("Sum")
                                .build())
                            .returnData(false)
                            .build(),
                        PolicyTargetTrackingConfigurationCustomizedMetricSpecificationMetricArgs.builder()
                            .id("m2")
                            .label("Get the group size (the number of InService instances)")
                            .metricStat(PolicyTargetTrackingConfigurationCustomizedMetricSpecificationMetricMetricStatArgs.builder()
                                .metric(PolicyTargetTrackingConfigurationCustomizedMetricSpecificationMetricMetricStatMetricArgs.builder()
                                    .dimensions(PolicyTargetTrackingConfigurationCustomizedMetricSpecificationMetricMetricStatMetricDimensionArgs.builder()
                                        .name("AutoScalingGroupName")
                                        .value("my-asg")
                                        .build())
                                    .metricName("GroupInServiceInstances")
                                    .namespace("AWS/AutoScaling")
                                    .build())
                                .stat("Average")
                                .build())
                            .returnData(false)
                            .build(),
                        PolicyTargetTrackingConfigurationCustomizedMetricSpecificationMetricArgs.builder()
                            .expression("m1 / m2")
                            .id("e1")
                            .label("Calculate the backlog per instance")
                            .returnData(true)
                            .build())
                    .build())
                .targetValue(100)
                .build())
            .build());
    }
}

Create predictive scaling policy using customized metrics

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.autoscaling.Policy;
import com.pulumi.aws.autoscaling.PolicyArgs;
import com.pulumi.aws.autoscaling.inputs.PolicyPredictiveScalingConfigurationArgs;
import com.pulumi.aws.autoscaling.inputs.PolicyPredictiveScalingConfigurationMetricSpecificationArgs;
import com.pulumi.aws.autoscaling.inputs.PolicyPredictiveScalingConfigurationMetricSpecificationCustomizedCapacityMetricSpecificationArgs;
import com.pulumi.aws.autoscaling.inputs.PolicyPredictiveScalingConfigurationMetricSpecificationCustomizedLoadMetricSpecificationArgs;
import com.pulumi.aws.autoscaling.inputs.PolicyPredictiveScalingConfigurationMetricSpecificationCustomizedScalingMetricSpecificationArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var example = new Policy("example", PolicyArgs.builder()
            .autoscalingGroupName("my-test-asg")
            .policyType("PredictiveScaling")
            .predictiveScalingConfiguration(PolicyPredictiveScalingConfigurationArgs.builder()
                .metricSpecification(PolicyPredictiveScalingConfigurationMetricSpecificationArgs.builder()
                    .customizedCapacityMetricSpecification(PolicyPredictiveScalingConfigurationMetricSpecificationCustomizedCapacityMetricSpecificationArgs.builder()
                        .metricDataQueries(PolicyPredictiveScalingConfigurationMetricSpecificationCustomizedCapacityMetricSpecificationMetricDataQueryArgs.builder()
                            .expression("SUM(SEARCH('{AWS/AutoScaling,AutoScalingGroupName} MetricName=\"GroupInServiceIntances\" my-test-asg', 'Average', 300))")
                            .id("capacity_sum")
                            .build())
                        .build())
                    .customizedLoadMetricSpecification(PolicyPredictiveScalingConfigurationMetricSpecificationCustomizedLoadMetricSpecificationArgs.builder()
                        .metricDataQueries(PolicyPredictiveScalingConfigurationMetricSpecificationCustomizedLoadMetricSpecificationMetricDataQueryArgs.builder()
                            .expression("SUM(SEARCH('{AWS/EC2,AutoScalingGroupName} MetricName=\"CPUUtilization\" my-test-asg', 'Sum', 3600))")
                            .id("load_sum")
                            .build())
                        .build())
                    .customizedScalingMetricSpecification(PolicyPredictiveScalingConfigurationMetricSpecificationCustomizedScalingMetricSpecificationArgs.builder()
                        .metricDataQueries(
                            PolicyPredictiveScalingConfigurationMetricSpecificationCustomizedScalingMetricSpecificationMetricDataQueryArgs.builder()
                                .expression("SUM(SEARCH('{AWS/AutoScaling,AutoScalingGroupName} MetricName=\"GroupInServiceIntances\" my-test-asg', 'Average', 300))")
                                .id("capacity_sum")
                                .returnData(false)
                                .build(),
                            PolicyPredictiveScalingConfigurationMetricSpecificationCustomizedScalingMetricSpecificationMetricDataQueryArgs.builder()
                                .expression("SUM(SEARCH('{AWS/EC2,AutoScalingGroupName} MetricName=\"CPUUtilization\" my-test-asg', 'Sum', 300))")
                                .id("load_sum")
                                .returnData(false)
                                .build(),
                            PolicyPredictiveScalingConfigurationMetricSpecificationCustomizedScalingMetricSpecificationMetricDataQueryArgs.builder()
                                .expression("load_sum / (capacity_sum * PERIOD(capacity_sum) / 60)")
                                .id("weighted_average")
                                .build())
                        .build())
                    .targetValue(10)
                    .build())
                .build())
            .build());
    }
}

Create predictive scaling policy using customized scaling and predefined load metric

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.autoscaling.Policy;
import com.pulumi.aws.autoscaling.PolicyArgs;
import com.pulumi.aws.autoscaling.inputs.PolicyPredictiveScalingConfigurationArgs;
import com.pulumi.aws.autoscaling.inputs.PolicyPredictiveScalingConfigurationMetricSpecificationArgs;
import com.pulumi.aws.autoscaling.inputs.PolicyPredictiveScalingConfigurationMetricSpecificationCustomizedScalingMetricSpecificationArgs;
import com.pulumi.aws.autoscaling.inputs.PolicyPredictiveScalingConfigurationMetricSpecificationPredefinedLoadMetricSpecificationArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var example = new Policy("example", PolicyArgs.builder()
            .autoscalingGroupName("my-test-asg")
            .policyType("PredictiveScaling")
            .predictiveScalingConfiguration(PolicyPredictiveScalingConfigurationArgs.builder()
                .metricSpecification(PolicyPredictiveScalingConfigurationMetricSpecificationArgs.builder()
                    .customizedScalingMetricSpecification(PolicyPredictiveScalingConfigurationMetricSpecificationCustomizedScalingMetricSpecificationArgs.builder()
                        .metricDataQueries(PolicyPredictiveScalingConfigurationMetricSpecificationCustomizedScalingMetricSpecificationMetricDataQueryArgs.builder()
                            .id("scaling")
                            .metricStat(PolicyPredictiveScalingConfigurationMetricSpecificationCustomizedScalingMetricSpecificationMetricDataQueryMetricStatArgs.builder()
                                .metric(PolicyPredictiveScalingConfigurationMetricSpecificationCustomizedScalingMetricSpecificationMetricDataQueryMetricStatMetricArgs.builder()
                                    .dimensions(PolicyPredictiveScalingConfigurationMetricSpecificationCustomizedScalingMetricSpecificationMetricDataQueryMetricStatMetricDimensionArgs.builder()
                                        .name("AutoScalingGroupName")
                                        .value("my-test-asg")
                                        .build())
                                    .metricName("CPUUtilization")
                                    .namespace("AWS/EC2")
                                    .build())
                                .stat("Average")
                                .build())
                            .build())
                        .build())
                    .predefinedLoadMetricSpecification(PolicyPredictiveScalingConfigurationMetricSpecificationPredefinedLoadMetricSpecificationArgs.builder()
                        .predefinedMetricType("ASGTotalCPUUtilization")
                        .resourceLabel("testLabel")
                        .build())
                    .targetValue(10)
                    .build())
                .build())
            .build());
    }
}

Import

Using pulumi import, import AutoScaling scaling policy using the role autoscaling_group_name and name separated by /. For example:

$ pulumi import aws:autoscaling/policy:Policy test-policy asg-name/policy-name

Constructors

PolicyArgs

fun PolicyArgs(adjustmentType: Output<String>? = null, autoscalingGroupName: Output<String>? = null, cooldown: Output<Int>? = null, enabled: Output<Boolean>? = null, estimatedInstanceWarmup: Output<Int>? = null, metricAggregationType: Output<String>? = null, minAdjustmentMagnitude: Output<Int>? = null, name: Output<String>? = null, policyType: Output<String>? = null, predictiveScalingConfiguration: Output<PolicyPredictiveScalingConfigurationArgs>? = null, scalingAdjustment: Output<Int>? = null, stepAdjustments: Output<List<PolicyStepAdjustmentArgs>>? = null, targetTrackingConfiguration: Output<PolicyTargetTrackingConfigurationArgs>? = null)

Functions

toJava

open override fun toJava(): PolicyArgs

Properties

adjustmentType

val adjustmentType: Output<String>? = null

Whether the adjustment is an absolute number or a percentage of the current capacity. Valid values are ChangeInCapacity, ExactCapacity, and PercentChangeInCapacity.

autoscalingGroupName

val autoscalingGroupName: Output<String>? = null

Name of the autoscaling group.

cooldown

val cooldown: Output<Int>? = null

Amount of time, in seconds, after a scaling activity completes and before the next scaling activity can start.

enabled

val enabled: Output<Boolean>? = null

Whether the scaling policy is enabled or disabled. Default: true. The following argument is only available to "SimpleScaling" and "StepScaling" type policies:

estimatedInstanceWarmup

val estimatedInstanceWarmup: Output<Int>? = null

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.

metricAggregationType

val metricAggregationType: Output<String>? = null

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".

minAdjustmentMagnitude

val minAdjustmentMagnitude: Output<Int>? = null

Minimum value to scale by when adjustment_type is set to PercentChangeInCapacity. The following arguments are only available to "SimpleScaling" type policies:

name

val name: Output<String>? = null

Name of the policy.

policyType

val policyType: Output<String>? = null

Policy type, either "SimpleScaling", "StepScaling", "TargetTrackingScaling", or "PredictiveScaling". If this value isn't provided, AWS will default to "SimpleScaling."

predictiveScalingConfiguration

val predictiveScalingConfiguration: Output<PolicyPredictiveScalingConfigurationArgs>? = null

Predictive scaling policy configuration to use with Amazon EC2 Auto Scaling.

scalingAdjustment

val scalingAdjustment: Output<Int>? = null

Number of members by which to scale, when the adjustment bounds are breached. A positive value scales up. A negative value scales down.

stepAdjustments

val stepAdjustments: Output<List<PolicyStepAdjustmentArgs>>? = null

Set of adjustments that manage group scaling. These have the following structure:

targetTrackingConfiguration

val targetTrackingConfiguration: Output<PolicyTargetTrackingConfigurationArgs>? = null

Target tracking policy. These have the following structure: