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

PolicyArgs

data class PolicyArgs(val name: Output<String>? = null, val policyType: Output<String>? = null, val resourceId: Output<String>? = null, val scalableDimension: Output<String>? = null, val serviceNamespace: Output<String>? = null, val stepScalingPolicyConfiguration: Output<PolicyStepScalingPolicyConfigurationArgs>? = null, val targetTrackingScalingPolicyConfiguration: Output<PolicyTargetTrackingScalingPolicyConfigurationArgs>? = null) : ConvertibleToJava<PolicyArgs>

Provides an Application AutoScaling Policy resource.

Example Usage

DynamoDB Table Autoscaling

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.appautoscaling.Target;
import com.pulumi.aws.appautoscaling.TargetArgs;
import com.pulumi.aws.appautoscaling.Policy;
import com.pulumi.aws.appautoscaling.PolicyArgs;
import com.pulumi.aws.appautoscaling.inputs.PolicyTargetTrackingScalingPolicyConfigurationArgs;
import com.pulumi.aws.appautoscaling.inputs.PolicyTargetTrackingScalingPolicyConfigurationPredefinedMetricSpecificationArgs;
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 dynamodbTableReadTarget = new Target("dynamodbTableReadTarget", TargetArgs.builder()
            .maxCapacity(100)
            .minCapacity(5)
            .resourceId("table/tableName")
            .scalableDimension("dynamodb:table:ReadCapacityUnits")
            .serviceNamespace("dynamodb")
            .build());
        var dynamodbTableReadPolicy = new Policy("dynamodbTableReadPolicy", PolicyArgs.builder()
            .policyType("TargetTrackingScaling")
            .resourceId(dynamodbTableReadTarget.resourceId())
            .scalableDimension(dynamodbTableReadTarget.scalableDimension())
            .serviceNamespace(dynamodbTableReadTarget.serviceNamespace())
            .targetTrackingScalingPolicyConfiguration(PolicyTargetTrackingScalingPolicyConfigurationArgs.builder()
                .predefinedMetricSpecification(PolicyTargetTrackingScalingPolicyConfigurationPredefinedMetricSpecificationArgs.builder()
                    .predefinedMetricType("DynamoDBReadCapacityUtilization")
                    .build())
                .targetValue(70)
                .build())
            .build());
    }
}
Content copied to clipboard

ECS Service Autoscaling

No Java example available.

Preserve desired count when updating an autoscaled ECS Service

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ecs.Service;
import com.pulumi.aws.ecs.ServiceArgs;
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 ecsService = new Service("ecsService", ServiceArgs.builder()
            .cluster("clusterName")
            .taskDefinition("taskDefinitionFamily:1")
            .desiredCount(2)
            .build());
    }
}
Content copied to clipboard

Aurora Read Replica Autoscaling

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.appautoscaling.Target;
import com.pulumi.aws.appautoscaling.TargetArgs;
import com.pulumi.aws.appautoscaling.Policy;
import com.pulumi.aws.appautoscaling.PolicyArgs;
import com.pulumi.aws.appautoscaling.inputs.PolicyTargetTrackingScalingPolicyConfigurationArgs;
import com.pulumi.aws.appautoscaling.inputs.PolicyTargetTrackingScalingPolicyConfigurationPredefinedMetricSpecificationArgs;
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 replicasTarget = new Target("replicasTarget", TargetArgs.builder()
            .serviceNamespace("rds")
            .scalableDimension("rds:cluster:ReadReplicaCount")
            .resourceId(String.format("cluster:%s", aws_rds_cluster.example().id()))
            .minCapacity(1)
            .maxCapacity(15)
            .build());
        var replicasPolicy = new Policy("replicasPolicy", PolicyArgs.builder()
            .serviceNamespace(replicasTarget.serviceNamespace())
            .scalableDimension(replicasTarget.scalableDimension())
            .resourceId(replicasTarget.resourceId())
            .policyType("TargetTrackingScaling")
            .targetTrackingScalingPolicyConfiguration(PolicyTargetTrackingScalingPolicyConfigurationArgs.builder()
                .predefinedMetricSpecification(PolicyTargetTrackingScalingPolicyConfigurationPredefinedMetricSpecificationArgs.builder()
                    .predefinedMetricType("RDSReaderAverageCPUUtilization")
                    .build())
                .targetValue(75)
                .scaleInCooldown(300)
                .scaleOutCooldown(300)
                .build())
            .build());
    }
}
Content copied to clipboard

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.appautoscaling.Target;
import com.pulumi.aws.appautoscaling.TargetArgs;
import com.pulumi.aws.appautoscaling.Policy;
import com.pulumi.aws.appautoscaling.PolicyArgs;
import com.pulumi.aws.appautoscaling.inputs.PolicyTargetTrackingScalingPolicyConfigurationArgs;
import com.pulumi.aws.appautoscaling.inputs.PolicyTargetTrackingScalingPolicyConfigurationCustomizedMetricSpecificationArgs;
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 ecsTarget = new Target("ecsTarget", TargetArgs.builder()
            .maxCapacity(4)
            .minCapacity(1)
            .resourceId("service/clusterName/serviceName")
            .scalableDimension("ecs:service:DesiredCount")
            .serviceNamespace("ecs")
            .build());
        var example = new Policy("example", PolicyArgs.builder()
            .policyType("TargetTrackingScaling")
            .resourceId(ecsTarget.resourceId())
            .scalableDimension(ecsTarget.scalableDimension())
            .serviceNamespace(ecsTarget.serviceNamespace())
            .targetTrackingScalingPolicyConfiguration(PolicyTargetTrackingScalingPolicyConfigurationArgs.builder()
                .targetValue(100)
                .customizedMetricSpecification(PolicyTargetTrackingScalingPolicyConfigurationCustomizedMetricSpecificationArgs.builder()
                    .metrics(
                        PolicyTargetTrackingScalingPolicyConfigurationCustomizedMetricSpecificationMetricArgs.builder()
                            .label("Get the queue size (the number of messages waiting to be processed)")
                            .id("m1")
                            .metricStat(PolicyTargetTrackingScalingPolicyConfigurationCustomizedMetricSpecificationMetricMetricStatArgs.builder()
                                .metric(PolicyTargetTrackingScalingPolicyConfigurationCustomizedMetricSpecificationMetricMetricStatMetricArgs.builder()
                                    .metricName("ApproximateNumberOfMessagesVisible")
                                    .namespace("AWS/SQS")
                                    .dimensions(PolicyTargetTrackingScalingPolicyConfigurationCustomizedMetricSpecificationMetricMetricStatMetricDimensionArgs.builder()
                                        .name("QueueName")
                                        .value("my-queue")
                                        .build())
                                    .build())
                                .stat("Sum")
                                .build())
                            .returnData(false)
                            .build(),
                        PolicyTargetTrackingScalingPolicyConfigurationCustomizedMetricSpecificationMetricArgs.builder()
                            .label("Get the ECS running task count (the number of currently running tasks)")
                            .id("m2")
                            .metricStat(PolicyTargetTrackingScalingPolicyConfigurationCustomizedMetricSpecificationMetricMetricStatArgs.builder()
                                .metric(PolicyTargetTrackingScalingPolicyConfigurationCustomizedMetricSpecificationMetricMetricStatMetricArgs.builder()
                                    .metricName("RunningTaskCount")
                                    .namespace("ECS/ContainerInsights")
                                    .dimensions(
                                        PolicyTargetTrackingScalingPolicyConfigurationCustomizedMetricSpecificationMetricMetricStatMetricDimensionArgs.builder()
                                            .name("ClusterName")
                                            .value("default")
                                            .build(),
                                        PolicyTargetTrackingScalingPolicyConfigurationCustomizedMetricSpecificationMetricMetricStatMetricDimensionArgs.builder()
                                            .name("ServiceName")
                                            .value("web-app")
                                            .build())
                                    .build())
                                .stat("Average")
                                .build())
                            .returnData(false)
                            .build(),
                        PolicyTargetTrackingScalingPolicyConfigurationCustomizedMetricSpecificationMetricArgs.builder()
                            .label("Calculate the backlog per instance")
                            .id("e1")
                            .expression("m1 / m2")
                            .returnData(true)
                            .build())
                    .build())
                .build())
            .build());
    }
}
Content copied to clipboard

MSK / Kafka Autoscaling

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.appautoscaling.Target;
import com.pulumi.aws.appautoscaling.TargetArgs;
import com.pulumi.aws.appautoscaling.Policy;
import com.pulumi.aws.appautoscaling.PolicyArgs;
import com.pulumi.aws.appautoscaling.inputs.PolicyTargetTrackingScalingPolicyConfigurationArgs;
import com.pulumi.aws.appautoscaling.inputs.PolicyTargetTrackingScalingPolicyConfigurationPredefinedMetricSpecificationArgs;
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 mskTarget = new Target("mskTarget", TargetArgs.builder()
            .serviceNamespace("kafka")
            .scalableDimension("kafka:broker-storage:VolumeSize")
            .resourceId(aws_msk_cluster.example().arn())
            .minCapacity(1)
            .maxCapacity(8)
            .build());
        var targets = new Policy("targets", PolicyArgs.builder()
            .serviceNamespace(mskTarget.serviceNamespace())
            .scalableDimension(mskTarget.scalableDimension())
            .resourceId(mskTarget.resourceId())
            .policyType("TargetTrackingScaling")
            .targetTrackingScalingPolicyConfiguration(PolicyTargetTrackingScalingPolicyConfigurationArgs.builder()
                .predefinedMetricSpecification(PolicyTargetTrackingScalingPolicyConfigurationPredefinedMetricSpecificationArgs.builder()
                    .predefinedMetricType("KafkaBrokerStorageUtilization")
                    .build())
                .targetValue(55)
                .build())
            .build());
    }
}
Content copied to clipboard

Import

Application AutoScaling Policy can be imported using the service-namespace , resource-id, scalable-dimension and policy-name separated by /.

$ pulumi import aws:appautoscaling/policy:Policy test-policy service-namespace/resource-id/scalable-dimension/policy-name
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(name: Output<String>? = null, policyType: Output<String>? = null, resourceId: Output<String>? = null, scalableDimension: Output<String>? = null, serviceNamespace: Output<String>? = null, stepScalingPolicyConfiguration: Output<PolicyStepScalingPolicyConfigurationArgs>? = null, targetTrackingScalingPolicyConfiguration: Output<PolicyTargetTrackingScalingPolicyConfigurationArgs>? = null)

Properties

Link copied to clipboard
val name: Output<String>? = null

Name of the policy. Must be between 1 and 255 characters in length.

Link copied to clipboard
val policyType: Output<String>? = null

Policy type. Valid values are StepScaling and TargetTrackingScaling. Defaults to StepScaling. Certain services only support only one policy type. For more information see the Target Tracking Scaling Policies and Step Scaling Policies documentation.

Link copied to clipboard
val resourceId: Output<String>? = null

Resource type and unique identifier string for the resource associated with the scaling policy. Documentation can be found in the ResourceId parameter at: AWS Application Auto Scaling API Reference

Link copied to clipboard
val scalableDimension: Output<String>? = null

Scalable dimension of the scalable target. Documentation can be found in the ScalableDimension parameter at: AWS Application Auto Scaling API Reference

Link copied to clipboard
val serviceNamespace: Output<String>? = null

AWS service namespace of the scalable target. Documentation can be found in the ServiceNamespace parameter at: AWS Application Auto Scaling API Reference

Link copied to clipboard
val stepScalingPolicyConfiguration: Output<PolicyStepScalingPolicyConfigurationArgs>? = null

Step scaling policy configuration, requires policy_type = "StepScaling" (default). See supported fields below.

Link copied to clipboard
val targetTrackingScalingPolicyConfiguration: Output<PolicyTargetTrackingScalingPolicyConfigurationArgs>? = null

Target tracking policy, requires policy_type = "TargetTrackingScaling". See supported fields below.

Functions

Link copied to clipboard
open override fun toJava(): PolicyArgs