volcengine.autoscaling.ScalingPolicy

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Volcengine = Pulumi.Volcengine;

return await Deployment.RunAsync(() => 
{
    var fooZones = Volcengine.Ecs.Zones.Invoke();

    var fooVpc = new Volcengine.Vpc.Vpc("fooVpc", new()
    {
        VpcName = "acc-test-vpc",
        CidrBlock = "172.16.0.0/16",
    });

    var fooSubnet = new Volcengine.Vpc.Subnet("fooSubnet", new()
    {
        SubnetName = "acc-test-subnet",
        CidrBlock = "172.16.0.0/24",
        ZoneId = fooZones.Apply(zonesResult => zonesResult.Zones[0]?.Id),
        VpcId = fooVpc.Id,
    });

    var fooScalingGroup = new Volcengine.Autoscaling.ScalingGroup("fooScalingGroup", new()
    {
        ScalingGroupName = "acc-test-scaling-group",
        SubnetIds = new[]
        {
            fooSubnet.Id,
        },
        MultiAzPolicy = "BALANCE",
        DesireInstanceNumber = 0,
        MinInstanceNumber = 0,
        MaxInstanceNumber = 1,
        InstanceTerminatePolicy = "OldestInstance",
        DefaultCooldown = 10,
    });

    var fooScalingPolicy = new Volcengine.Autoscaling.ScalingPolicy("fooScalingPolicy", new()
    {
        Active = false,
        ScalingGroupId = fooScalingGroup.Id,
        ScalingPolicyName = "acc-tf-sg-policy-test",
        ScalingPolicyType = "Alarm",
        AdjustmentType = "QuantityChangeInCapacity",
        AdjustmentValue = 100,
        Cooldown = 10,
        AlarmPolicyRuleType = "Static",
        AlarmPolicyEvaluationCount = 1,
        AlarmPolicyConditionMetricName = "Instance_CpuBusy_Avg",
        AlarmPolicyConditionMetricUnit = "Percent",
        AlarmPolicyConditionComparisonOperator = "=",
        AlarmPolicyConditionThreshold = "100",
    });

});

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/autoscaling"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/ecs"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/vpc"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		fooZones, err := ecs.Zones(ctx, nil, nil)
		if err != nil {
			return err
		}
		fooVpc, err := vpc.NewVpc(ctx, "fooVpc", &vpc.VpcArgs{
			VpcName:   pulumi.String("acc-test-vpc"),
			CidrBlock: pulumi.String("172.16.0.0/16"),
		})
		if err != nil {
			return err
		}
		fooSubnet, err := vpc.NewSubnet(ctx, "fooSubnet", &vpc.SubnetArgs{
			SubnetName: pulumi.String("acc-test-subnet"),
			CidrBlock:  pulumi.String("172.16.0.0/24"),
			ZoneId:     *pulumi.String(fooZones.Zones[0].Id),
			VpcId:      fooVpc.ID(),
		})
		if err != nil {
			return err
		}
		fooScalingGroup, err := autoscaling.NewScalingGroup(ctx, "fooScalingGroup", &autoscaling.ScalingGroupArgs{
			ScalingGroupName: pulumi.String("acc-test-scaling-group"),
			SubnetIds: pulumi.StringArray{
				fooSubnet.ID(),
			},
			MultiAzPolicy:           pulumi.String("BALANCE"),
			DesireInstanceNumber:    pulumi.Int(0),
			MinInstanceNumber:       pulumi.Int(0),
			MaxInstanceNumber:       pulumi.Int(1),
			InstanceTerminatePolicy: pulumi.String("OldestInstance"),
			DefaultCooldown:         pulumi.Int(10),
		})
		if err != nil {
			return err
		}
		_, err = autoscaling.NewScalingPolicy(ctx, "fooScalingPolicy", &autoscaling.ScalingPolicyArgs{
			Active:                                 pulumi.Bool(false),
			ScalingGroupId:                         fooScalingGroup.ID(),
			ScalingPolicyName:                      pulumi.String("acc-tf-sg-policy-test"),
			ScalingPolicyType:                      pulumi.String("Alarm"),
			AdjustmentType:                         pulumi.String("QuantityChangeInCapacity"),
			AdjustmentValue:                        pulumi.Int(100),
			Cooldown:                               pulumi.Int(10),
			AlarmPolicyRuleType:                    pulumi.String("Static"),
			AlarmPolicyEvaluationCount:             pulumi.Int(1),
			AlarmPolicyConditionMetricName:         pulumi.String("Instance_CpuBusy_Avg"),
			AlarmPolicyConditionMetricUnit:         pulumi.String("Percent"),
			AlarmPolicyConditionComparisonOperator: pulumi.String("="),
			AlarmPolicyConditionThreshold:          pulumi.String("100"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.volcengine.ecs.EcsFunctions;
import com.pulumi.volcengine.ecs.inputs.ZonesArgs;
import com.pulumi.volcengine.vpc.Vpc;
import com.pulumi.volcengine.vpc.VpcArgs;
import com.pulumi.volcengine.vpc.Subnet;
import com.pulumi.volcengine.vpc.SubnetArgs;
import com.pulumi.volcengine.autoscaling.ScalingGroup;
import com.pulumi.volcengine.autoscaling.ScalingGroupArgs;
import com.pulumi.volcengine.autoscaling.ScalingPolicy;
import com.pulumi.volcengine.autoscaling.ScalingPolicyArgs;
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) {
        final var fooZones = EcsFunctions.Zones();

        var fooVpc = new Vpc("fooVpc", VpcArgs.builder()        
            .vpcName("acc-test-vpc")
            .cidrBlock("172.16.0.0/16")
            .build());

        var fooSubnet = new Subnet("fooSubnet", SubnetArgs.builder()        
            .subnetName("acc-test-subnet")
            .cidrBlock("172.16.0.0/24")
            .zoneId(fooZones.applyValue(zonesResult -> zonesResult.zones()[0].id()))
            .vpcId(fooVpc.id())
            .build());

        var fooScalingGroup = new ScalingGroup("fooScalingGroup", ScalingGroupArgs.builder()        
            .scalingGroupName("acc-test-scaling-group")
            .subnetIds(fooSubnet.id())
            .multiAzPolicy("BALANCE")
            .desireInstanceNumber(0)
            .minInstanceNumber(0)
            .maxInstanceNumber(1)
            .instanceTerminatePolicy("OldestInstance")
            .defaultCooldown(10)
            .build());

        var fooScalingPolicy = new ScalingPolicy("fooScalingPolicy", ScalingPolicyArgs.builder()        
            .active(false)
            .scalingGroupId(fooScalingGroup.id())
            .scalingPolicyName("acc-tf-sg-policy-test")
            .scalingPolicyType("Alarm")
            .adjustmentType("QuantityChangeInCapacity")
            .adjustmentValue(100)
            .cooldown(10)
            .alarmPolicyRuleType("Static")
            .alarmPolicyEvaluationCount(1)
            .alarmPolicyConditionMetricName("Instance_CpuBusy_Avg")
            .alarmPolicyConditionMetricUnit("Percent")
            .alarmPolicyConditionComparisonOperator("=")
            .alarmPolicyConditionThreshold(100)
            .build());

    }
}

import pulumi
import pulumi_volcengine as volcengine

foo_zones = volcengine.ecs.zones()
foo_vpc = volcengine.vpc.Vpc("fooVpc",
    vpc_name="acc-test-vpc",
    cidr_block="172.16.0.0/16")
foo_subnet = volcengine.vpc.Subnet("fooSubnet",
    subnet_name="acc-test-subnet",
    cidr_block="172.16.0.0/24",
    zone_id=foo_zones.zones[0].id,
    vpc_id=foo_vpc.id)
foo_scaling_group = volcengine.autoscaling.ScalingGroup("fooScalingGroup",
    scaling_group_name="acc-test-scaling-group",
    subnet_ids=[foo_subnet.id],
    multi_az_policy="BALANCE",
    desire_instance_number=0,
    min_instance_number=0,
    max_instance_number=1,
    instance_terminate_policy="OldestInstance",
    default_cooldown=10)
foo_scaling_policy = volcengine.autoscaling.ScalingPolicy("fooScalingPolicy",
    active=False,
    scaling_group_id=foo_scaling_group.id,
    scaling_policy_name="acc-tf-sg-policy-test",
    scaling_policy_type="Alarm",
    adjustment_type="QuantityChangeInCapacity",
    adjustment_value=100,
    cooldown=10,
    alarm_policy_rule_type="Static",
    alarm_policy_evaluation_count=1,
    alarm_policy_condition_metric_name="Instance_CpuBusy_Avg",
    alarm_policy_condition_metric_unit="Percent",
    alarm_policy_condition_comparison_operator="=",
    alarm_policy_condition_threshold="100")

import * as pulumi from "@pulumi/pulumi";
import * as volcengine from "@pulumi/volcengine";
import * as volcengine from "@volcengine/pulumi";

const fooZones = volcengine.ecs.Zones({});
const fooVpc = new volcengine.vpc.Vpc("fooVpc", {
    vpcName: "acc-test-vpc",
    cidrBlock: "172.16.0.0/16",
});
const fooSubnet = new volcengine.vpc.Subnet("fooSubnet", {
    subnetName: "acc-test-subnet",
    cidrBlock: "172.16.0.0/24",
    zoneId: fooZones.then(fooZones => fooZones.zones?.[0]?.id),
    vpcId: fooVpc.id,
});
const fooScalingGroup = new volcengine.autoscaling.ScalingGroup("fooScalingGroup", {
    scalingGroupName: "acc-test-scaling-group",
    subnetIds: [fooSubnet.id],
    multiAzPolicy: "BALANCE",
    desireInstanceNumber: 0,
    minInstanceNumber: 0,
    maxInstanceNumber: 1,
    instanceTerminatePolicy: "OldestInstance",
    defaultCooldown: 10,
});
const fooScalingPolicy = new volcengine.autoscaling.ScalingPolicy("fooScalingPolicy", {
    active: false,
    scalingGroupId: fooScalingGroup.id,
    scalingPolicyName: "acc-tf-sg-policy-test",
    scalingPolicyType: "Alarm",
    adjustmentType: "QuantityChangeInCapacity",
    adjustmentValue: 100,
    cooldown: 10,
    alarmPolicyRuleType: "Static",
    alarmPolicyEvaluationCount: 1,
    alarmPolicyConditionMetricName: "Instance_CpuBusy_Avg",
    alarmPolicyConditionMetricUnit: "Percent",
    alarmPolicyConditionComparisonOperator: "=",
    alarmPolicyConditionThreshold: "100",
});

resources:
  fooVpc:
    type: volcengine:vpc:Vpc
    properties:
      vpcName: acc-test-vpc
      cidrBlock: 172.16.0.0/16
  fooSubnet:
    type: volcengine:vpc:Subnet
    properties:
      subnetName: acc-test-subnet
      cidrBlock: 172.16.0.0/24
      zoneId: ${fooZones.zones[0].id}
      vpcId: ${fooVpc.id}
  fooScalingGroup:
    type: volcengine:autoscaling:ScalingGroup
    properties:
      scalingGroupName: acc-test-scaling-group
      subnetIds:
        - ${fooSubnet.id}
      multiAzPolicy: BALANCE
      desireInstanceNumber: 0
      minInstanceNumber: 0
      maxInstanceNumber: 1
      instanceTerminatePolicy: OldestInstance
      defaultCooldown: 10
  fooScalingPolicy:
    type: volcengine:autoscaling:ScalingPolicy
    properties:
      active: false
      scalingGroupId: ${fooScalingGroup.id}
      scalingPolicyName: acc-tf-sg-policy-test
      scalingPolicyType: Alarm
      adjustmentType: QuantityChangeInCapacity
      adjustmentValue: 100
      cooldown: 10
      alarmPolicyRuleType: Static
      alarmPolicyEvaluationCount: 1
      alarmPolicyConditionMetricName: Instance_CpuBusy_Avg
      alarmPolicyConditionMetricUnit: Percent
      alarmPolicyConditionComparisonOperator: =
      alarmPolicyConditionThreshold: 100
variables:
  fooZones:
    fn::invoke:
      Function: volcengine:ecs:Zones
      Arguments: {}