ServerGroup

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") ?? "slbservergroupvpc";
        var defaultZones = Output.Create(AliCloud.GetZones.InvokeAsync(new AliCloud.GetZonesArgs
        {
            AvailableDiskCategory = "cloud_efficiency",
            AvailableResourceCreation = "VSwitch",
        }));
        var defaultInstanceTypes = defaultZones.Apply(defaultZones => Output.Create(AliCloud.Ecs.GetInstanceTypes.InvokeAsync(new AliCloud.Ecs.GetInstanceTypesArgs
        {
            AvailabilityZone = defaultZones.Zones[0].Id,
            CpuCoreCount = 1,
            MemorySize = 2,
        })));
        var defaultImages = Output.Create(AliCloud.Ecs.GetImages.InvokeAsync(new AliCloud.Ecs.GetImagesArgs
        {
            MostRecent = true,
            NameRegex = "^ubuntu_18.*64",
            Owners = "system",
        }));
        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/16",
            VpcId = defaultNetwork.Id,
        });
        var defaultSecurityGroup = new AliCloud.Ecs.SecurityGroup("defaultSecurityGroup", new AliCloud.Ecs.SecurityGroupArgs
        {
            VpcId = defaultNetwork.Id,
        });
        var instance = new List<AliCloud.Ecs.Instance>();
        for (var rangeIndex = 0; rangeIndex < 2; rangeIndex++)
        {
            var range = new { Value = rangeIndex };
            instance.Add(new AliCloud.Ecs.Instance($"instance-{range.Value}", new AliCloud.Ecs.InstanceArgs
            {
                AvailabilityZone = defaultZones.Apply(defaultZones => defaultZones.Zones[0].Id),
                ImageId = defaultImages.Apply(defaultImages => defaultImages.Images[0].Id),
                InstanceChargeType = "PostPaid",
                InstanceName = name,
                InstanceType = defaultInstanceTypes.Apply(defaultInstanceTypes => defaultInstanceTypes.InstanceTypes[0].Id),
                InternetChargeType = "PayByTraffic",
                InternetMaxBandwidthOut = 10,
                SecurityGroups = 
                {
                    defaultSecurityGroup,
                }.Select(__item => __item.Id).ToList(),
                SystemDiskCategory = "cloud_efficiency",
                VswitchId = defaultSwitch.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,
            Servers = 
            {
                new AliCloud.Slb.Inputs.ServerGroupServerArgs
                {
                    Port = 100,
                    ServerIds = 
                    {
                        instance[0].Id,
                        instance[1].Id,
                    },
                    Weight = 10,
                },
                new AliCloud.Slb.Inputs.ServerGroupServerArgs
                {
                    Port = 80,
                    ServerIds = instance.Select(__item => __item.Id).ToList(),
                    Weight = 100,
                },
            },
        });
    }

}

import pulumi
import pulumi_alicloud as alicloud

config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "slbservergroupvpc"
default_zones = alicloud.get_zones(available_disk_category="cloud_efficiency",
    available_resource_creation="VSwitch")
default_instance_types = alicloud.ecs.get_instance_types(availability_zone=default_zones.zones[0]["id"],
    cpu_core_count=1,
    memory_size=2)
default_images = alicloud.ecs.get_images(most_recent=True,
    name_regex="^ubuntu_18.*64",
    owners="system")
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/16",
    vpc_id=default_network.id)
default_security_group = alicloud.ecs.SecurityGroup("defaultSecurityGroup", vpc_id=default_network.id)
instance = []
for range in [{"value": i} for i in range(0, 2)]:
    instance.append(alicloud.ecs.Instance(f"instance-{range['value']}",
        availability_zone=default_zones.zones[0]["id"],
        image_id=default_images.images[0]["id"],
        instance_charge_type="PostPaid",
        instance_name=name,
        instance_type=default_instance_types.instance_types[0]["id"],
        internet_charge_type="PayByTraffic",
        internet_max_bandwidth_out="10",
        security_groups=[__item.id for __item in [default_security_group]],
        system_disk_category="cloud_efficiency",
        vswitch_id=default_switch.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,
    servers=[
        {
            "port": 100,
            "serverIds": [
                instance[0].id,
                instance[1].id,
            ],
            "weight": 10,
        },
        {
            "port": 80,
            "serverIds": [__item.id for __item in instance],
            "weight": 100,
        },
    ])

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

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

const defaultZones = pulumi.output(alicloud.getZones({
    availableDiskCategory: "cloud_efficiency",
    availableResourceCreation: "VSwitch",
}, { async: true }));
const defaultInstanceTypes = defaultZones.apply(defaultZones => alicloud.ecs.getInstanceTypes({
    availabilityZone: defaultZones.zones[0].id,
    cpuCoreCount: 1,
    memorySize: 2,
}, { async: true }));
const defaultImages = pulumi.output(alicloud.ecs.getImages({
    mostRecent: true,
    nameRegex: "^ubuntu_18.*64",
    owners: "system",
}, { 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/16",
    vpcId: defaultNetwork.id,
});
const defaultSecurityGroup = new alicloud.ecs.SecurityGroup("default", {
    vpcId: defaultNetwork.id,
});
const instance: alicloud.ecs.Instance[] = [];
for (let i = 0; i < 2; i++) {
    instance.push(new alicloud.ecs.Instance(`instance-${i}`, {
        availabilityZone: defaultZones.zones[0].id,
        imageId: defaultImages.images[0].id,
        instanceChargeType: "PostPaid",
        instanceName: name,
        instanceType: defaultInstanceTypes.instanceTypes[0].id,
        internetChargeType: "PayByTraffic",
        internetMaxBandwidthOut: 10,
        securityGroups: defaultSecurityGroup.id,
        systemDiskCategory: "cloud_efficiency",
        vswitchId: defaultSwitch.id,
    }));
}
const defaultLoadBalancer = new alicloud.slb.LoadBalancer("default", {
    vswitchId: defaultSwitch.id,
});
const defaultServerGroup = new alicloud.slb.ServerGroup("default", {
    loadBalancerId: defaultLoadBalancer.id,
    servers: [
        {
            port: 100,
            serverIds: [
                instance[0].id,
                instance[1].id,
            ],
            weight: 10,
        },
        {
            port: 80,
            serverIds: instance.map(v => v.id),
            weight: 100,
        },
    ],
});