pulumi-alicloud-kotlin/com.pulumi.alicloud.ess.kotlin/ScalingGroup

ScalingGroup

class ScalingGroup : KotlinCustomResource

Provides a ESS scaling group resource which is a collection of ECS instances with the same application scenarios. It defines the maximum and minimum numbers of ECS instances in the group, and their associated Server Load Balancer instances, RDS instances, and other attributes.

NOTE: You can launch an ESS scaling group for a VPC network via specifying parameter vswitch_ids. For information about ess scaling rule, see CreateScalingGroup. NOTE: Available since v1.39.0.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as alicloud from "@pulumi/alicloud";
import * as random from "@pulumi/random";
const config = new pulumi.Config();
const name = config.get("name") || "terraform-example";
const defaultInteger = new random.index.Integer("default", {
    min: 10000,
    max: 99999,
});
const myName = `${name}-${defaultInteger.result}`;
const default = alicloud.getZones({
    availableDiskCategory: "cloud_efficiency",
    availableResourceCreation: "VSwitch",
});
const defaultGetInstanceTypes = _default.then(_default => alicloud.ecs.getInstanceTypes({
    availabilityZone: _default.zones?.[0]?.id,
    cpuCoreCount: 2,
    memorySize: 4,
}));
const defaultGetImages = alicloud.ecs.getImages({
    nameRegex: "^ubuntu_18.*64",
    mostRecent: true,
    owners: "system",
});
const defaultNetwork = new alicloud.vpc.Network("default", {
    vpcName: myName,
    cidrBlock: "172.16.0.0/16",
});
const defaultSwitch = new alicloud.vpc.Switch("default", {
    vpcId: defaultNetwork.id,
    cidrBlock: "172.16.0.0/24",
    zoneId: _default.then(_default => _default.zones?.[0]?.id),
    vswitchName: myName,
});
const defaultSecurityGroup = new alicloud.ecs.SecurityGroup("default", {
    name: myName,
    vpcId: defaultNetwork.id,
});
const defaultSecurityGroupRule = new alicloud.ecs.SecurityGroupRule("default", {
    type: "ingress",
    ipProtocol: "tcp",
    nicType: "intranet",
    policy: "accept",
    portRange: "22/22",
    priority: 1,
    securityGroupId: defaultSecurityGroup.id,
    cidrIp: "172.16.0.0/24",
});
const default2 = new alicloud.vpc.Switch("default2", {
    vpcId: defaultNetwork.id,
    cidrBlock: "172.16.1.0/24",
    zoneId: _default.then(_default => _default.zones?.[0]?.id),
    vswitchName: `${name}-bar`,
});
const defaultScalingGroup = new alicloud.ess.ScalingGroup("default", {
    minSize: 1,
    maxSize: 1,
    scalingGroupName: myName,
    defaultCooldown: 20,
    vswitchIds: [
        defaultSwitch.id,
        default2.id,
    ],
    removalPolicies: [
        "OldestInstance",
        "NewestInstance",
    ],
});

import pulumi
import pulumi_alicloud as alicloud
import pulumi_random as random
config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "terraform-example"
default_integer = random.index.Integer("default",
    min=10000,
    max=99999)
my_name = f"{name}-{default_integer['result']}"
default = alicloud.get_zones(available_disk_category="cloud_efficiency",
    available_resource_creation="VSwitch")
default_get_instance_types = alicloud.ecs.get_instance_types(availability_zone=default.zones[0].id,
    cpu_core_count=2,
    memory_size=4)
default_get_images = alicloud.ecs.get_images(name_regex="^ubuntu_18.*64",
    most_recent=True,
    owners="system")
default_network = alicloud.vpc.Network("default",
    vpc_name=my_name,
    cidr_block="172.16.0.0/16")
default_switch = alicloud.vpc.Switch("default",
    vpc_id=default_network.id,
    cidr_block="172.16.0.0/24",
    zone_id=default.zones[0].id,
    vswitch_name=my_name)
default_security_group = alicloud.ecs.SecurityGroup("default",
    name=my_name,
    vpc_id=default_network.id)
default_security_group_rule = alicloud.ecs.SecurityGroupRule("default",
    type="ingress",
    ip_protocol="tcp",
    nic_type="intranet",
    policy="accept",
    port_range="22/22",
    priority=1,
    security_group_id=default_security_group.id,
    cidr_ip="172.16.0.0/24")
default2 = alicloud.vpc.Switch("default2",
    vpc_id=default_network.id,
    cidr_block="172.16.1.0/24",
    zone_id=default.zones[0].id,
    vswitch_name=f"{name}-bar")
default_scaling_group = alicloud.ess.ScalingGroup("default",
    min_size=1,
    max_size=1,
    scaling_group_name=my_name,
    default_cooldown=20,
    vswitch_ids=[
        default_switch.id,
        default2.id,
    ],
    removal_policies=[
        "OldestInstance",
        "NewestInstance",
    ])

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AliCloud = Pulumi.AliCloud;
using Random = Pulumi.Random;
return await Deployment.RunAsync(() =>
{
    var config = new Config();
    var name = config.Get("name") ?? "terraform-example";
    var defaultInteger = new Random.Index.Integer("default", new()
    {
        Min = 10000,
        Max = 99999,
    });
    var myName = $"{name}-{defaultInteger.Result}";
    var @default = AliCloud.GetZones.Invoke(new()
    {
        AvailableDiskCategory = "cloud_efficiency",
        AvailableResourceCreation = "VSwitch",
    });
    var defaultGetInstanceTypes = AliCloud.Ecs.GetInstanceTypes.Invoke(new()
    {
        AvailabilityZone = @default.Apply(getZonesResult => getZonesResult.Zones[0]?.Id),
        CpuCoreCount = 2,
        MemorySize = 4,
    });
    var defaultGetImages = AliCloud.Ecs.GetImages.Invoke(new()
    {
        NameRegex = "^ubuntu_18.*64",
        MostRecent = true,
        Owners = "system",
    });
    var defaultNetwork = new AliCloud.Vpc.Network("default", new()
    {
        VpcName = myName,
        CidrBlock = "172.16.0.0/16",
    });
    var defaultSwitch = new AliCloud.Vpc.Switch("default", new()
    {
        VpcId = defaultNetwork.Id,
        CidrBlock = "172.16.0.0/24",
        ZoneId = @default.Apply(@default => @default.Apply(getZonesResult => getZonesResult.Zones[0]?.Id)),
        VswitchName = myName,
    });
    var defaultSecurityGroup = new AliCloud.Ecs.SecurityGroup("default", new()
    {
        Name = myName,
        VpcId = defaultNetwork.Id,
    });
    var defaultSecurityGroupRule = new AliCloud.Ecs.SecurityGroupRule("default", new()
    {
        Type = "ingress",
        IpProtocol = "tcp",
        NicType = "intranet",
        Policy = "accept",
        PortRange = "22/22",
        Priority = 1,
        SecurityGroupId = defaultSecurityGroup.Id,
        CidrIp = "172.16.0.0/24",
    });
    var default2 = new AliCloud.Vpc.Switch("default2", new()
    {
        VpcId = defaultNetwork.Id,
        CidrBlock = "172.16.1.0/24",
        ZoneId = @default.Apply(@default => @default.Apply(getZonesResult => getZonesResult.Zones[0]?.Id)),
        VswitchName = $"{name}-bar",
    });
    var defaultScalingGroup = new AliCloud.Ess.ScalingGroup("default", new()
    {
        MinSize = 1,
        MaxSize = 1,
        ScalingGroupName = myName,
        DefaultCooldown = 20,
        VswitchIds = new[]
        {
            defaultSwitch.Id,
            default2.Id,
        },
        RemovalPolicies = new[]
        {
            "OldestInstance",
            "NewestInstance",
        },
    });
});

package main
import (
	"fmt"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/ecs"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/ess"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/vpc"
	"github.com/pulumi/pulumi-random/sdk/v4/go/random"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		name := "terraform-example"
		if param := cfg.Get("name"); param != "" {
			name = param
		}
		defaultInteger, err := random.NewInteger(ctx, "default", &random.IntegerArgs{
			Min: 10000,
			Max: 99999,
		})
		if err != nil {
			return err
		}
		myName := fmt.Sprintf("%v-%v", name, defaultInteger.Result)
		_default, err := alicloud.GetZones(ctx, &alicloud.GetZonesArgs{
			AvailableDiskCategory:     pulumi.StringRef("cloud_efficiency"),
			AvailableResourceCreation: pulumi.StringRef("VSwitch"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = ecs.GetInstanceTypes(ctx, &ecs.GetInstanceTypesArgs{
			AvailabilityZone: pulumi.StringRef(_default.Zones[0].Id),
			CpuCoreCount:     pulumi.IntRef(2),
			MemorySize:       pulumi.Float64Ref(4),
		}, nil)
		if err != nil {
			return err
		}
		_, err = ecs.GetImages(ctx, &ecs.GetImagesArgs{
			NameRegex:  pulumi.StringRef("^ubuntu_18.*64"),
			MostRecent: pulumi.BoolRef(true),
			Owners:     pulumi.StringRef("system"),
		}, nil)
		if err != nil {
			return err
		}
		defaultNetwork, err := vpc.NewNetwork(ctx, "default", &vpc.NetworkArgs{
			VpcName:   pulumi.String(myName),
			CidrBlock: pulumi.String("172.16.0.0/16"),
		})
		if err != nil {
			return err
		}
		defaultSwitch, err := vpc.NewSwitch(ctx, "default", &vpc.SwitchArgs{
			VpcId:       defaultNetwork.ID(),
			CidrBlock:   pulumi.String("172.16.0.0/24"),
			ZoneId:      pulumi.String(_default.Zones[0].Id),
			VswitchName: pulumi.String(myName),
		})
		if err != nil {
			return err
		}
		defaultSecurityGroup, err := ecs.NewSecurityGroup(ctx, "default", &ecs.SecurityGroupArgs{
			Name:  pulumi.String(myName),
			VpcId: defaultNetwork.ID(),
		})
		if err != nil {
			return err
		}
		_, err = ecs.NewSecurityGroupRule(ctx, "default", &ecs.SecurityGroupRuleArgs{
			Type:            pulumi.String("ingress"),
			IpProtocol:      pulumi.String("tcp"),
			NicType:         pulumi.String("intranet"),
			Policy:          pulumi.String("accept"),
			PortRange:       pulumi.String("22/22"),
			Priority:        pulumi.Int(1),
			SecurityGroupId: defaultSecurityGroup.ID(),
			CidrIp:          pulumi.String("172.16.0.0/24"),
		})
		if err != nil {
			return err
		}
		default2, err := vpc.NewSwitch(ctx, "default2", &vpc.SwitchArgs{
			VpcId:       defaultNetwork.ID(),
			CidrBlock:   pulumi.String("172.16.1.0/24"),
			ZoneId:      pulumi.String(_default.Zones[0].Id),
			VswitchName: pulumi.String(fmt.Sprintf("%v-bar", name)),
		})
		if err != nil {
			return err
		}
		_, err = ess.NewScalingGroup(ctx, "default", &ess.ScalingGroupArgs{
			MinSize:          pulumi.Int(1),
			MaxSize:          pulumi.Int(1),
			ScalingGroupName: pulumi.String(myName),
			DefaultCooldown:  pulumi.Int(20),
			VswitchIds: pulumi.StringArray{
				defaultSwitch.ID(),
				default2.ID(),
			},
			RemovalPolicies: pulumi.StringArray{
				pulumi.String("OldestInstance"),
				pulumi.String("NewestInstance"),
			},
		})
		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.random.integer;
import com.pulumi.random.IntegerArgs;
import com.pulumi.alicloud.AlicloudFunctions;
import com.pulumi.alicloud.inputs.GetZonesArgs;
import com.pulumi.alicloud.ecs.EcsFunctions;
import com.pulumi.alicloud.ecs.inputs.GetInstanceTypesArgs;
import com.pulumi.alicloud.ecs.inputs.GetImagesArgs;
import com.pulumi.alicloud.vpc.Network;
import com.pulumi.alicloud.vpc.NetworkArgs;
import com.pulumi.alicloud.vpc.Switch;
import com.pulumi.alicloud.vpc.SwitchArgs;
import com.pulumi.alicloud.ecs.SecurityGroup;
import com.pulumi.alicloud.ecs.SecurityGroupArgs;
import com.pulumi.alicloud.ecs.SecurityGroupRule;
import com.pulumi.alicloud.ecs.SecurityGroupRuleArgs;
import com.pulumi.alicloud.ess.ScalingGroup;
import com.pulumi.alicloud.ess.ScalingGroupArgs;
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 config = ctx.config();
        final var name = config.get("name").orElse("terraform-example");
        var defaultInteger = new Integer("defaultInteger", IntegerArgs.builder()
            .min(10000)
            .max(99999)
            .build());
        final var myName = String.format("%s-%s", name,defaultInteger.result());
        final var default = AlicloudFunctions.getZones(GetZonesArgs.builder()
            .availableDiskCategory("cloud_efficiency")
            .availableResourceCreation("VSwitch")
            .build());
        final var defaultGetInstanceTypes = EcsFunctions.getInstanceTypes(GetInstanceTypesArgs.builder()
            .availabilityZone(default_.zones()[0].id())
            .cpuCoreCount(2)
            .memorySize(4)
            .build());
        final var defaultGetImages = EcsFunctions.getImages(GetImagesArgs.builder()
            .nameRegex("^ubuntu_18.*64")
            .mostRecent(true)
            .owners("system")
            .build());
        var defaultNetwork = new Network("defaultNetwork", NetworkArgs.builder()
            .vpcName(myName)
            .cidrBlock("172.16.0.0/16")
            .build());
        var defaultSwitch = new Switch("defaultSwitch", SwitchArgs.builder()
            .vpcId(defaultNetwork.id())
            .cidrBlock("172.16.0.0/24")
            .zoneId(default_.zones()[0].id())
            .vswitchName(myName)
            .build());
        var defaultSecurityGroup = new SecurityGroup("defaultSecurityGroup", SecurityGroupArgs.builder()
            .name(myName)
            .vpcId(defaultNetwork.id())
            .build());
        var defaultSecurityGroupRule = new SecurityGroupRule("defaultSecurityGroupRule", SecurityGroupRuleArgs.builder()
            .type("ingress")
            .ipProtocol("tcp")
            .nicType("intranet")
            .policy("accept")
            .portRange("22/22")
            .priority(1)
            .securityGroupId(defaultSecurityGroup.id())
            .cidrIp("172.16.0.0/24")
            .build());
        var default2 = new Switch("default2", SwitchArgs.builder()
            .vpcId(defaultNetwork.id())
            .cidrBlock("172.16.1.0/24")
            .zoneId(default_.zones()[0].id())
            .vswitchName(String.format("%s-bar", name))
            .build());
        var defaultScalingGroup = new ScalingGroup("defaultScalingGroup", ScalingGroupArgs.builder()
            .minSize(1)
            .maxSize(1)
            .scalingGroupName(myName)
            .defaultCooldown(20)
            .vswitchIds(
                defaultSwitch.id(),
                default2.id())
            .removalPolicies(
                "OldestInstance",
                "NewestInstance")
            .build());
    }
}

configuration:
  name:
    type: string
    default: terraform-example
resources:
  defaultInteger:
    type: random:integer
    name: default
    properties:
      min: 10000
      max: 99999
  defaultNetwork:
    type: alicloud:vpc:Network
    name: default
    properties:
      vpcName: ${myName}
      cidrBlock: 172.16.0.0/16
  defaultSwitch:
    type: alicloud:vpc:Switch
    name: default
    properties:
      vpcId: ${defaultNetwork.id}
      cidrBlock: 172.16.0.0/24
      zoneId: ${default.zones[0].id}
      vswitchName: ${myName}
  defaultSecurityGroup:
    type: alicloud:ecs:SecurityGroup
    name: default
    properties:
      name: ${myName}
      vpcId: ${defaultNetwork.id}
  defaultSecurityGroupRule:
    type: alicloud:ecs:SecurityGroupRule
    name: default
    properties:
      type: ingress
      ipProtocol: tcp
      nicType: intranet
      policy: accept
      portRange: 22/22
      priority: 1
      securityGroupId: ${defaultSecurityGroup.id}
      cidrIp: 172.16.0.0/24
  default2:
    type: alicloud:vpc:Switch
    properties:
      vpcId: ${defaultNetwork.id}
      cidrBlock: 172.16.1.0/24
      zoneId: ${default.zones[0].id}
      vswitchName: ${name}-bar
  defaultScalingGroup:
    type: alicloud:ess:ScalingGroup
    name: default
    properties:
      minSize: 1
      maxSize: 1
      scalingGroupName: ${myName}
      defaultCooldown: 20
      vswitchIds:
        - ${defaultSwitch.id}
        - ${default2.id}
      removalPolicies:
        - OldestInstance
        - NewestInstance
variables:
  myName: ${name}-${defaultInteger.result}
  default:
    fn::invoke:
      Function: alicloud:getZones
      Arguments:
        availableDiskCategory: cloud_efficiency
        availableResourceCreation: VSwitch
  defaultGetInstanceTypes:
    fn::invoke:
      Function: alicloud:ecs:getInstanceTypes
      Arguments:
        availabilityZone: ${default.zones[0].id}
        cpuCoreCount: 2
        memorySize: 4
  defaultGetImages:
    fn::invoke:
      Function: alicloud:ecs:getImages
      Arguments:
        nameRegex: ^ubuntu_18.*64
        mostRecent: true
        owners: system

Module Support

You can use to the existing autoscaling module to create a scaling group, configuration and lifecycle hook one-click.

Import

ESS scaling group can be imported using the id, e.g.

$ pulumi import alicloud:ess/scalingGroup:ScalingGroup example asg-abc123456

Properties

albServerGroups

val albServerGroups: Output<List<ScalingGroupAlbServerGroup>>?

If a Serve ALB instance is specified in the scaling group, the scaling group automatically attaches its ECS instances to the Server ALB instance. See alb_server_group below for details.

dbInstanceIds

val dbInstanceIds: Output<List<String>>?

If an RDS instance is specified in the scaling group, the scaling group automatically attaches the Intranet IP addresses of its ECS instances to the RDS access whitelist.

defaultCooldown

val defaultCooldown: Output<Int>?

Default cool-down time (in seconds) of the scaling group. Value range: 0, 86400. The default value is 300s.

desiredCapacity

val desiredCapacity: Output<Int>?

Expected number of ECS instances in the scaling group. Value range: min_size, max_size.

groupDeletionProtection

val groupDeletionProtection: Output<Boolean>?

Specifies whether the scaling group deletion protection is enabled. true or false, Default value: false.

groupType

val groupType: Output<String>

Resource type within scaling group. Optional values: ECS, ECI. Default to ECS.

healthCheckType

val healthCheckType: Output<String>

Resource type within scaling group. Optional values: ECS, NONE, LOAD_BALANCER. Default to ECS.

val id: Output<String>

launchTemplateId

val launchTemplateId: Output<String>?

Instance launch template ID, scaling group obtains launch configuration from instance launch template, see Launch Template. Creating scaling group from launch template enable group automatically.

launchTemplateOverrides

val launchTemplateOverrides: Output<List<ScalingGroupLaunchTemplateOverride>>?

The details of the instance types that are specified by using the Extend Instance Type of Launch Template feature. See launch_template_override below for details.

launchTemplateVersion

val launchTemplateVersion: Output<String>?

The version number of the launch template. Valid values are the version number, Latest, or Default, Default value: Default.

loadbalancerIds

val loadbalancerIds: Output<List<String>>?

If a Server Load Balancer instance is specified in the scaling group, the scaling group automatically attaches its ECS instances to the Server Load Balancer instance.

maxSize

val maxSize: Output<Int>

Maximum number of ECS instances in the scaling group. Value range: 0, 2000. NOTE: From version 1.204.1, max_size can be set to 2000.

minSize

val minSize: Output<Int>

Minimum number of ECS instances in the scaling group. Value range: 0, 2000. NOTE: From version 1.204.1, min_size can be set to 2000.

multiAzPolicy

val multiAzPolicy: Output<String>?

Multi-AZ scaling group ECS instance expansion and contraction strategy. PRIORITY, BALANCE or COST_OPTIMIZED(Available since v1.54.0).

onDemandBaseCapacity

val onDemandBaseCapacity: Output<Int>

The minimum amount of the Auto Scaling group's capacity that must be fulfilled by On-Demand Instances. This base portion is provisioned first as your group scales.

onDemandPercentageAboveBaseCapacity

val onDemandPercentageAboveBaseCapacity: Output<Int>

Controls the percentages of On-Demand Instances and Spot Instances for your additional capacity beyond OnDemandBaseCapacity.

protectedInstances

val protectedInstances: Output<List<String>>?

Set or unset instances within group into protected status.

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

removalPolicies

val removalPolicies: Output<List<String>>

RemovalPolicy is used to select the ECS instances you want to remove from the scaling group when multiple candidates for removal exist. Optional values:

resourceGroupId

val resourceGroupId: Output<String>

The ID of the resource group to which you want to add the scaling group.

scalingGroupName

val scalingGroupName: Output<String>?

Name shown for the scaling group, which must contain 2-64 characters (English or Chinese), starting with numbers, English letters or Chinese characters, and can contain numbers, underscores _, hyphens -, and decimal points .. If this parameter is not specified, the default value is ScalingGroupId.

spotInstancePools

val spotInstancePools: Output<Int>

The number of Spot pools to use to allocate your Spot capacity. The Spot pools is composed of instance types of lowest price.

spotInstanceRemedy

val spotInstanceRemedy: Output<Boolean>

Whether to replace spot instances with newly created spot/onDemand instance when receive a spot recycling message.