ScalingGroupVServerGroups

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

class MyStack : Stack
{
    public MyStack()
    {
        var config = new Config();
        var name = config.Get("name") ?? "testAccEssVserverGroupsAttachment";
        var defaultZones = Output.Create(AliCloud.GetZones.InvokeAsync(new AliCloud.GetZonesArgs
        {
            AvailableDiskCategory = "cloud_efficiency",
            AvailableResourceCreation = "VSwitch",
        }));
        var defaultNetwork = new AliCloud.Vpc.Network("defaultNetwork", new AliCloud.Vpc.NetworkArgs
        {
            CidrBlock = "172.16.0.0/16",
        });
        var defaultSwitch = new AliCloud.Vpc.Switch("defaultSwitch", new AliCloud.Vpc.SwitchArgs
        {
            AvailabilityZone = defaultZones.Apply(defaultZones => defaultZones.Zones[0].Id),
            CidrBlock = "172.16.0.0/24",
            VpcId = defaultNetwork.Id,
        });
        var defaultLoadBalancer = new AliCloud.Slb.LoadBalancer("defaultLoadBalancer", new AliCloud.Slb.LoadBalancerArgs
        {
            VswitchId = defaultSwitch.Id,
        });
        var defaultServerGroup = new AliCloud.Slb.ServerGroup("defaultServerGroup", new AliCloud.Slb.ServerGroupArgs
        {
            LoadBalancerId = defaultLoadBalancer.Id,
        });
        var defaultListener = new List<AliCloud.Slb.Listener>();
        for (var rangeIndex = 0; rangeIndex < 2; rangeIndex++)
        {
            var range = new { Value = rangeIndex };
            defaultListener.Add(new AliCloud.Slb.Listener($"defaultListener-{range.Value}", new AliCloud.Slb.ListenerArgs
            {
                BackendPort = 22,
                Bandwidth = 10,
                FrontendPort = 22,
                HealthCheckType = "tcp",
                LoadBalancerId = 
                {
                    defaultLoadBalancer,
                }.Select(__item => __item.Id).ToList()[range.Value],
                Protocol = "tcp",
            }));
        }
        var defaultScalingGroup = new AliCloud.Ess.ScalingGroup("defaultScalingGroup", new AliCloud.Ess.ScalingGroupArgs
        {
            MaxSize = 2,
            MinSize = 2,
            ScalingGroupName = name,
            VswitchIds = 
            {
                defaultSwitch.Id,
            },
        });
        var defaultScalingGroupVServerGroups = new AliCloud.Ess.ScalingGroupVServerGroups("defaultScalingGroupVServerGroups", new AliCloud.Ess.ScalingGroupVServerGroupsArgs
        {
            ScalingGroupId = defaultScalingGroup.Id,
            VserverGroups = 
            {
                new AliCloud.Ess.Inputs.ScalingGroupVServerGroupsVserverGroupArgs
                {
                    LoadbalancerId = defaultLoadBalancer.Id,
                    VserverAttributes = 
                    {
                        new AliCloud.Ess.Inputs.ScalingGroupVServerGroupsVserverGroupVserverAttributeArgs
                        {
                            Port = 100,
                            VserverGroupId = defaultServerGroup.Id,
                            Weight = 60,
                        },
                    },
                },
            },
        });
    }

}

import pulumi
import pulumi_alicloud as alicloud

config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "testAccEssVserverGroupsAttachment"
default_zones = alicloud.get_zones(available_disk_category="cloud_efficiency",
    available_resource_creation="VSwitch")
default_network = alicloud.vpc.Network("defaultNetwork", cidr_block="172.16.0.0/16")
default_switch = alicloud.vpc.Switch("defaultSwitch",
    availability_zone=default_zones.zones[0]["id"],
    cidr_block="172.16.0.0/24",
    vpc_id=default_network.id)
default_load_balancer = alicloud.slb.LoadBalancer("defaultLoadBalancer", vswitch_id=default_switch.id)
default_server_group = alicloud.slb.ServerGroup("defaultServerGroup", load_balancer_id=default_load_balancer.id)
default_listener = []
for range in [{"value": i} for i in range(0, 2)]:
    default_listener.append(alicloud.slb.Listener(f"defaultListener-{range['value']}",
        backend_port="22",
        bandwidth="10",
        frontend_port="22",
        health_check_type="tcp",
        load_balancer_id=[__item.id for __item in [default_load_balancer]][range["value"]],
        protocol="tcp"))
default_scaling_group = alicloud.ess.ScalingGroup("defaultScalingGroup",
    max_size="2",
    min_size="2",
    scaling_group_name=name,
    vswitch_ids=[default_switch.id])
default_scaling_group_v_server_groups = alicloud.ess.ScalingGroupVServerGroups("defaultScalingGroupVServerGroups",
    scaling_group_id=default_scaling_group.id,
    vserver_groups=[{
        "loadbalancerId": default_load_balancer.id,
        "vserverAttributes": [{
            "port": "100",
            "vserver_group_id": default_server_group.id,
            "weight": "60",
        }],
    }])

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

const config = new pulumi.Config();
const name = config.get("name") || "testAccEssVserverGroupsAttachment";

const defaultZones = pulumi.output(alicloud.getZones({
    availableDiskCategory: "cloud_efficiency",
    availableResourceCreation: "VSwitch",
}, { async: true }));
const defaultNetwork = new alicloud.vpc.Network("default", {
    cidrBlock: "172.16.0.0/16",
});
const defaultSwitch = new alicloud.vpc.Switch("default", {
    availabilityZone: defaultZones.zones[0].id,
    cidrBlock: "172.16.0.0/24",
    vpcId: defaultNetwork.id,
});
const defaultLoadBalancer = new alicloud.slb.LoadBalancer("default", {
    vswitchId: defaultSwitch.id,
});
const defaultServerGroup = new alicloud.slb.ServerGroup("default", {
    loadBalancerId: defaultLoadBalancer.id,
});
const defaultListener: alicloud.slb.Listener[] = [];
for (let i = 0; i < 2; i++) {
    defaultListener.push(new alicloud.slb.Listener(`default-${i}`, {
        backendPort: 22,
        bandwidth: 10,
        frontendPort: 22,
        healthCheckType: "tcp",
        loadBalancerId: defaultLoadBalancer.id.apply(id => id[i]),
        protocol: "tcp",
    }));
}
const defaultScalingGroup = new alicloud.ess.ScalingGroup("default", {
    maxSize: 2,
    minSize: 2,
    scalingGroupName: name,
    vswitchIds: [defaultSwitch.id],
});
const defaultScalingGroupVServerGroups = new alicloud.ess.ScalingGroupVServerGroups("default", {
    scalingGroupId: defaultScalingGroup.id,
    vserverGroups: [{
        loadbalancerId: defaultLoadBalancer.id,
        vserverAttributes: [{
            port: 100,
            vserverGroupId: defaultServerGroup.id,
            weight: 60,
        }],
    }],
});