volcengine.autoscaling.ScalingConfiguration

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 fooSecurityGroup = new Volcengine.Vpc.SecurityGroup("fooSecurityGroup", new()
    {
        SecurityGroupName = "acc-test-security-group",
        VpcId = fooVpc.Id,
    });

    var fooImages = Volcengine.Ecs.Images.Invoke(new()
    {
        OsType = "Linux",
        Visibility = "public",
        InstanceTypeId = "ecs.g1.large",
    });

    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 fooScalingConfiguration = new Volcengine.Autoscaling.ScalingConfiguration("fooScalingConfiguration", new()
    {
        ScalingConfigurationName = "tf-test",
        ScalingGroupId = fooScalingGroup.Id,
        ImageId = fooImages.Apply(imagesResult => imagesResult.Images[0]?.ImageId),
        InstanceTypes = new[]
        {
            "ecs.g2i.large",
        },
        InstanceName = "tf-test",
        InstanceDescription = "",
        HostName = "",
        Password = "",
        KeyPairName = "tf-keypair",
        SecurityEnhancementStrategy = "InActive",
        Volumes = new[]
        {
            new Volcengine.Autoscaling.Inputs.ScalingConfigurationVolumeArgs
            {
                VolumeType = "ESSD_PL0",
                Size = 20,
                DeleteWithInstance = false,
            },
            new Volcengine.Autoscaling.Inputs.ScalingConfigurationVolumeArgs
            {
                VolumeType = "ESSD_PL0",
                Size = 50,
                DeleteWithInstance = true,
            },
        },
        SecurityGroupIds = new[]
        {
            fooSecurityGroup.Id,
        },
        EipBandwidth = 10,
        EipIsp = "ChinaMobile",
        EipBillingType = "PostPaidByBandwidth",
        UserData = "IyEvYmluL2Jhc2gKZWNobyAidGVzdCI=",
        Tags = new[]
        {
            new Volcengine.Autoscaling.Inputs.ScalingConfigurationTagArgs
            {
                Key = "tf-key1",
                Value = "tf-value1",
            },
            new Volcengine.Autoscaling.Inputs.ScalingConfigurationTagArgs
            {
                Key = "tf-key2",
                Value = "tf-value2",
            },
        },
        ProjectName = "default",
        HpcClusterId = "",
        SpotStrategy = "NoSpot",
    });

});

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
		}
		fooSecurityGroup, err := vpc.NewSecurityGroup(ctx, "fooSecurityGroup", &vpc.SecurityGroupArgs{
			SecurityGroupName: pulumi.String("acc-test-security-group"),
			VpcId:             fooVpc.ID(),
		})
		if err != nil {
			return err
		}
		fooImages, err := ecs.Images(ctx, &ecs.ImagesArgs{
			OsType:         pulumi.StringRef("Linux"),
			Visibility:     pulumi.StringRef("public"),
			InstanceTypeId: pulumi.StringRef("ecs.g1.large"),
		}, nil)
		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.NewScalingConfiguration(ctx, "fooScalingConfiguration", &autoscaling.ScalingConfigurationArgs{
			ScalingConfigurationName: pulumi.String("tf-test"),
			ScalingGroupId:           fooScalingGroup.ID(),
			ImageId:                  *pulumi.String(fooImages.Images[0].ImageId),
			InstanceTypes: pulumi.StringArray{
				pulumi.String("ecs.g2i.large"),
			},
			InstanceName:                pulumi.String("tf-test"),
			InstanceDescription:         pulumi.String(""),
			HostName:                    pulumi.String(""),
			Password:                    pulumi.String(""),
			KeyPairName:                 pulumi.String("tf-keypair"),
			SecurityEnhancementStrategy: pulumi.String("InActive"),
			Volumes: autoscaling.ScalingConfigurationVolumeArray{
				&autoscaling.ScalingConfigurationVolumeArgs{
					VolumeType:         pulumi.String("ESSD_PL0"),
					Size:               pulumi.Int(20),
					DeleteWithInstance: pulumi.Bool(false),
				},
				&autoscaling.ScalingConfigurationVolumeArgs{
					VolumeType:         pulumi.String("ESSD_PL0"),
					Size:               pulumi.Int(50),
					DeleteWithInstance: pulumi.Bool(true),
				},
			},
			SecurityGroupIds: pulumi.StringArray{
				fooSecurityGroup.ID(),
			},
			EipBandwidth:   pulumi.Int(10),
			EipIsp:         pulumi.String("ChinaMobile"),
			EipBillingType: pulumi.String("PostPaidByBandwidth"),
			UserData:       pulumi.String("IyEvYmluL2Jhc2gKZWNobyAidGVzdCI="),
			Tags: autoscaling.ScalingConfigurationTagArray{
				&autoscaling.ScalingConfigurationTagArgs{
					Key:   pulumi.String("tf-key1"),
					Value: pulumi.String("tf-value1"),
				},
				&autoscaling.ScalingConfigurationTagArgs{
					Key:   pulumi.String("tf-key2"),
					Value: pulumi.String("tf-value2"),
				},
			},
			ProjectName:  pulumi.String("default"),
			HpcClusterId: pulumi.String(""),
			SpotStrategy: pulumi.String("NoSpot"),
		})
		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.vpc.SecurityGroup;
import com.pulumi.volcengine.vpc.SecurityGroupArgs;
import com.pulumi.volcengine.ecs.inputs.ImagesArgs;
import com.pulumi.volcengine.autoscaling.ScalingGroup;
import com.pulumi.volcengine.autoscaling.ScalingGroupArgs;
import com.pulumi.volcengine.autoscaling.ScalingConfiguration;
import com.pulumi.volcengine.autoscaling.ScalingConfigurationArgs;
import com.pulumi.volcengine.autoscaling.inputs.ScalingConfigurationVolumeArgs;
import com.pulumi.volcengine.autoscaling.inputs.ScalingConfigurationTagArgs;
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 fooSecurityGroup = new SecurityGroup("fooSecurityGroup", SecurityGroupArgs.builder()        
            .securityGroupName("acc-test-security-group")
            .vpcId(fooVpc.id())
            .build());

        final var fooImages = EcsFunctions.Images(ImagesArgs.builder()
            .osType("Linux")
            .visibility("public")
            .instanceTypeId("ecs.g1.large")
            .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 fooScalingConfiguration = new ScalingConfiguration("fooScalingConfiguration", ScalingConfigurationArgs.builder()        
            .scalingConfigurationName("tf-test")
            .scalingGroupId(fooScalingGroup.id())
            .imageId(fooImages.applyValue(imagesResult -> imagesResult.images()[0].imageId()))
            .instanceTypes("ecs.g2i.large")
            .instanceName("tf-test")
            .instanceDescription("")
            .hostName("")
            .password("")
            .keyPairName("tf-keypair")
            .securityEnhancementStrategy("InActive")
            .volumes(            
                ScalingConfigurationVolumeArgs.builder()
                    .volumeType("ESSD_PL0")
                    .size(20)
                    .deleteWithInstance(false)
                    .build(),
                ScalingConfigurationVolumeArgs.builder()
                    .volumeType("ESSD_PL0")
                    .size(50)
                    .deleteWithInstance(true)
                    .build())
            .securityGroupIds(fooSecurityGroup.id())
            .eipBandwidth(10)
            .eipIsp("ChinaMobile")
            .eipBillingType("PostPaidByBandwidth")
            .userData("IyEvYmluL2Jhc2gKZWNobyAidGVzdCI=")
            .tags(            
                ScalingConfigurationTagArgs.builder()
                    .key("tf-key1")
                    .value("tf-value1")
                    .build(),
                ScalingConfigurationTagArgs.builder()
                    .key("tf-key2")
                    .value("tf-value2")
                    .build())
            .projectName("default")
            .hpcClusterId("")
            .spotStrategy("NoSpot")
            .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_security_group = volcengine.vpc.SecurityGroup("fooSecurityGroup",
    security_group_name="acc-test-security-group",
    vpc_id=foo_vpc.id)
foo_images = volcengine.ecs.images(os_type="Linux",
    visibility="public",
    instance_type_id="ecs.g1.large")
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_configuration = volcengine.autoscaling.ScalingConfiguration("fooScalingConfiguration",
    scaling_configuration_name="tf-test",
    scaling_group_id=foo_scaling_group.id,
    image_id=foo_images.images[0].image_id,
    instance_types=["ecs.g2i.large"],
    instance_name="tf-test",
    instance_description="",
    host_name="",
    password="",
    key_pair_name="tf-keypair",
    security_enhancement_strategy="InActive",
    volumes=[
        volcengine.autoscaling.ScalingConfigurationVolumeArgs(
            volume_type="ESSD_PL0",
            size=20,
            delete_with_instance=False,
        ),
        volcengine.autoscaling.ScalingConfigurationVolumeArgs(
            volume_type="ESSD_PL0",
            size=50,
            delete_with_instance=True,
        ),
    ],
    security_group_ids=[foo_security_group.id],
    eip_bandwidth=10,
    eip_isp="ChinaMobile",
    eip_billing_type="PostPaidByBandwidth",
    user_data="IyEvYmluL2Jhc2gKZWNobyAidGVzdCI=",
    tags=[
        volcengine.autoscaling.ScalingConfigurationTagArgs(
            key="tf-key1",
            value="tf-value1",
        ),
        volcengine.autoscaling.ScalingConfigurationTagArgs(
            key="tf-key2",
            value="tf-value2",
        ),
    ],
    project_name="default",
    hpc_cluster_id="",
    spot_strategy="NoSpot")

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 fooSecurityGroup = new volcengine.vpc.SecurityGroup("fooSecurityGroup", {
    securityGroupName: "acc-test-security-group",
    vpcId: fooVpc.id,
});
const fooImages = volcengine.ecs.Images({
    osType: "Linux",
    visibility: "public",
    instanceTypeId: "ecs.g1.large",
});
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 fooScalingConfiguration = new volcengine.autoscaling.ScalingConfiguration("fooScalingConfiguration", {
    scalingConfigurationName: "tf-test",
    scalingGroupId: fooScalingGroup.id,
    imageId: fooImages.then(fooImages => fooImages.images?.[0]?.imageId),
    instanceTypes: ["ecs.g2i.large"],
    instanceName: "tf-test",
    instanceDescription: "",
    hostName: "",
    password: "",
    keyPairName: "tf-keypair",
    securityEnhancementStrategy: "InActive",
    volumes: [
        {
            volumeType: "ESSD_PL0",
            size: 20,
            deleteWithInstance: false,
        },
        {
            volumeType: "ESSD_PL0",
            size: 50,
            deleteWithInstance: true,
        },
    ],
    securityGroupIds: [fooSecurityGroup.id],
    eipBandwidth: 10,
    eipIsp: "ChinaMobile",
    eipBillingType: "PostPaidByBandwidth",
    userData: "IyEvYmluL2Jhc2gKZWNobyAidGVzdCI=",
    tags: [
        {
            key: "tf-key1",
            value: "tf-value1",
        },
        {
            key: "tf-key2",
            value: "tf-value2",
        },
    ],
    projectName: "default",
    hpcClusterId: "",
    spotStrategy: "NoSpot",
});

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}
  fooSecurityGroup:
    type: volcengine:vpc:SecurityGroup
    properties:
      securityGroupName: acc-test-security-group
      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
  fooScalingConfiguration:
    type: volcengine:autoscaling:ScalingConfiguration
    properties:
      scalingConfigurationName: tf-test
      scalingGroupId: ${fooScalingGroup.id}
      imageId: ${fooImages.images[0].imageId}
      instanceTypes:
        - ecs.g2i.large
      instanceName: tf-test
      instanceDescription:
      hostName:
      password:
      keyPairName: tf-keypair
      securityEnhancementStrategy: InActive
      volumes:
        - volumeType: ESSD_PL0
          size: 20
          deleteWithInstance: false
        - volumeType: ESSD_PL0
          size: 50
          deleteWithInstance: true
      securityGroupIds:
        - ${fooSecurityGroup.id}
      eipBandwidth: 10
      eipIsp: ChinaMobile
      eipBillingType: PostPaidByBandwidth
      userData: IyEvYmluL2Jhc2gKZWNobyAidGVzdCI=
      tags:
        - key: tf-key1
          value: tf-value1
        - key: tf-key2
          value: tf-value2
      projectName: default
      hpcClusterId:
      spotStrategy: NoSpot
variables:
  fooZones:
    fn::invoke:
      Function: volcengine:ecs:Zones
      Arguments: {}
  fooImages:
    fn::invoke:
      Function: volcengine:ecs:Images
      Arguments:
        osType: Linux
        visibility: public
        instanceTypeId: ecs.g1.large