alicloud.alb.ServerGroup

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

const config = new pulumi.Config();
const name = config.get("name") || "terraform-example";
const example = alicloud.resourcemanager.getResourceGroups({});
const exampleGetZones = alicloud.getZones({
    availableResourceCreation: "Instance",
});
const exampleGetInstanceTypes = exampleGetZones.then(exampleGetZones => alicloud.ecs.getInstanceTypes({
    availabilityZone: exampleGetZones.zones?.[0]?.id,
    cpuCoreCount: 1,
    memorySize: 2,
}));
const exampleGetImages = alicloud.ecs.getImages({
    nameRegex: "^ubuntu_18.*64",
    owners: "system",
});
const exampleNetwork = new alicloud.vpc.Network("example", {
    vpcName: name,
    cidrBlock: "10.4.0.0/16",
});
const exampleSwitch = new alicloud.vpc.Switch("example", {
    vswitchName: name,
    cidrBlock: "10.4.0.0/16",
    vpcId: exampleNetwork.id,
    zoneId: exampleGetZones.then(exampleGetZones => exampleGetZones.zones?.[0]?.id),
});
const exampleSecurityGroup = new alicloud.ecs.SecurityGroup("example", {
    name: name,
    description: name,
    vpcId: exampleNetwork.id,
});
const exampleInstance = new alicloud.ecs.Instance("example", {
    availabilityZone: exampleGetZones.then(exampleGetZones => exampleGetZones.zones?.[0]?.id),
    instanceName: name,
    imageId: exampleGetImages.then(exampleGetImages => exampleGetImages.images?.[0]?.id),
    instanceType: exampleGetInstanceTypes.then(exampleGetInstanceTypes => exampleGetInstanceTypes.instanceTypes?.[0]?.id),
    securityGroups: [exampleSecurityGroup.id],
    vswitchId: exampleSwitch.id,
});
const exampleServerGroup = new alicloud.alb.ServerGroup("example", {
    protocol: "HTTP",
    vpcId: exampleNetwork.id,
    serverGroupName: name,
    resourceGroupId: example.then(example => example.groups?.[0]?.id),
    stickySessionConfig: {
        stickySessionEnabled: true,
        cookie: "tf-example",
        stickySessionType: "Server",
    },
    healthCheckConfig: {
        healthCheckConnectPort: 46325,
        healthCheckEnabled: true,
        healthCheckHost: "tf-example.com",
        healthCheckCodes: [
            "http_2xx",
            "http_3xx",
            "http_4xx",
        ],
        healthCheckHttpVersion: "HTTP1.1",
        healthCheckInterval: 2,
        healthCheckMethod: "HEAD",
        healthCheckPath: "/tf-example",
        healthCheckProtocol: "HTTP",
        healthCheckTimeout: 5,
        healthyThreshold: 3,
        unhealthyThreshold: 3,
    },
    servers: [{
        description: name,
        port: 80,
        serverId: exampleInstance.id,
        serverIp: exampleInstance.privateIp,
        serverType: "Ecs",
        weight: 10,
    }],
    tags: {
        Created: "TF",
    },
});

import pulumi
import pulumi_alicloud as alicloud

config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "terraform-example"
example = alicloud.resourcemanager.get_resource_groups()
example_get_zones = alicloud.get_zones(available_resource_creation="Instance")
example_get_instance_types = alicloud.ecs.get_instance_types(availability_zone=example_get_zones.zones[0].id,
    cpu_core_count=1,
    memory_size=2)
example_get_images = alicloud.ecs.get_images(name_regex="^ubuntu_18.*64",
    owners="system")
example_network = alicloud.vpc.Network("example",
    vpc_name=name,
    cidr_block="10.4.0.0/16")
example_switch = alicloud.vpc.Switch("example",
    vswitch_name=name,
    cidr_block="10.4.0.0/16",
    vpc_id=example_network.id,
    zone_id=example_get_zones.zones[0].id)
example_security_group = alicloud.ecs.SecurityGroup("example",
    name=name,
    description=name,
    vpc_id=example_network.id)
example_instance = alicloud.ecs.Instance("example",
    availability_zone=example_get_zones.zones[0].id,
    instance_name=name,
    image_id=example_get_images.images[0].id,
    instance_type=example_get_instance_types.instance_types[0].id,
    security_groups=[example_security_group.id],
    vswitch_id=example_switch.id)
example_server_group = alicloud.alb.ServerGroup("example",
    protocol="HTTP",
    vpc_id=example_network.id,
    server_group_name=name,
    resource_group_id=example.groups[0].id,
    sticky_session_config={
        "sticky_session_enabled": True,
        "cookie": "tf-example",
        "sticky_session_type": "Server",
    },
    health_check_config={
        "health_check_connect_port": 46325,
        "health_check_enabled": True,
        "health_check_host": "tf-example.com",
        "health_check_codes": [
            "http_2xx",
            "http_3xx",
            "http_4xx",
        ],
        "health_check_http_version": "HTTP1.1",
        "health_check_interval": 2,
        "health_check_method": "HEAD",
        "health_check_path": "/tf-example",
        "health_check_protocol": "HTTP",
        "health_check_timeout": 5,
        "healthy_threshold": 3,
        "unhealthy_threshold": 3,
    },
    servers=[{
        "description": name,
        "port": 80,
        "server_id": example_instance.id,
        "server_ip": example_instance.private_ip,
        "server_type": "Ecs",
        "weight": 10,
    }],
    tags={
        "Created": "TF",
    })

package main

import (
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/alb"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/ecs"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/resourcemanager"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/vpc"
	"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
		}
		example, err := resourcemanager.GetResourceGroups(ctx, &resourcemanager.GetResourceGroupsArgs{}, nil)
		if err != nil {
			return err
		}
		exampleGetZones, err := alicloud.GetZones(ctx, &alicloud.GetZonesArgs{
			AvailableResourceCreation: pulumi.StringRef("Instance"),
		}, nil)
		if err != nil {
			return err
		}
		exampleGetInstanceTypes, err := ecs.GetInstanceTypes(ctx, &ecs.GetInstanceTypesArgs{
			AvailabilityZone: pulumi.StringRef(exampleGetZones.Zones[0].Id),
			CpuCoreCount:     pulumi.IntRef(1),
			MemorySize:       pulumi.Float64Ref(2),
		}, nil)
		if err != nil {
			return err
		}
		exampleGetImages, err := ecs.GetImages(ctx, &ecs.GetImagesArgs{
			NameRegex: pulumi.StringRef("^ubuntu_18.*64"),
			Owners:    pulumi.StringRef("system"),
		}, nil)
		if err != nil {
			return err
		}
		exampleNetwork, err := vpc.NewNetwork(ctx, "example", &vpc.NetworkArgs{
			VpcName:   pulumi.String(name),
			CidrBlock: pulumi.String("10.4.0.0/16"),
		})
		if err != nil {
			return err
		}
		exampleSwitch, err := vpc.NewSwitch(ctx, "example", &vpc.SwitchArgs{
			VswitchName: pulumi.String(name),
			CidrBlock:   pulumi.String("10.4.0.0/16"),
			VpcId:       exampleNetwork.ID(),
			ZoneId:      pulumi.String(exampleGetZones.Zones[0].Id),
		})
		if err != nil {
			return err
		}
		exampleSecurityGroup, err := ecs.NewSecurityGroup(ctx, "example", &ecs.SecurityGroupArgs{
			Name:        pulumi.String(name),
			Description: pulumi.String(name),
			VpcId:       exampleNetwork.ID(),
		})
		if err != nil {
			return err
		}
		exampleInstance, err := ecs.NewInstance(ctx, "example", &ecs.InstanceArgs{
			AvailabilityZone: pulumi.String(exampleGetZones.Zones[0].Id),
			InstanceName:     pulumi.String(name),
			ImageId:          pulumi.String(exampleGetImages.Images[0].Id),
			InstanceType:     pulumi.String(exampleGetInstanceTypes.InstanceTypes[0].Id),
			SecurityGroups: pulumi.StringArray{
				exampleSecurityGroup.ID(),
			},
			VswitchId: exampleSwitch.ID(),
		})
		if err != nil {
			return err
		}
		_, err = alb.NewServerGroup(ctx, "example", &alb.ServerGroupArgs{
			Protocol:        pulumi.String("HTTP"),
			VpcId:           exampleNetwork.ID(),
			ServerGroupName: pulumi.String(name),
			ResourceGroupId: pulumi.String(example.Groups[0].Id),
			StickySessionConfig: &alb.ServerGroupStickySessionConfigArgs{
				StickySessionEnabled: pulumi.Bool(true),
				Cookie:               pulumi.String("tf-example"),
				StickySessionType:    pulumi.String("Server"),
			},
			HealthCheckConfig: &alb.ServerGroupHealthCheckConfigArgs{
				HealthCheckConnectPort: pulumi.Int(46325),
				HealthCheckEnabled:     pulumi.Bool(true),
				HealthCheckHost:        pulumi.String("tf-example.com"),
				HealthCheckCodes: pulumi.StringArray{
					pulumi.String("http_2xx"),
					pulumi.String("http_3xx"),
					pulumi.String("http_4xx"),
				},
				HealthCheckHttpVersion: pulumi.String("HTTP1.1"),
				HealthCheckInterval:    pulumi.Int(2),
				HealthCheckMethod:      pulumi.String("HEAD"),
				HealthCheckPath:        pulumi.String("/tf-example"),
				HealthCheckProtocol:    pulumi.String("HTTP"),
				HealthCheckTimeout:     pulumi.Int(5),
				HealthyThreshold:       pulumi.Int(3),
				UnhealthyThreshold:     pulumi.Int(3),
			},
			Servers: alb.ServerGroupServerArray{
				&alb.ServerGroupServerArgs{
					Description: pulumi.String(name),
					Port:        pulumi.Int(80),
					ServerId:    exampleInstance.ID(),
					ServerIp:    exampleInstance.PrivateIp,
					ServerType:  pulumi.String("Ecs"),
					Weight:      pulumi.Int(10),
				},
			},
			Tags: pulumi.StringMap{
				"Created": pulumi.String("TF"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var name = config.Get("name") ?? "terraform-example";
    var example = AliCloud.ResourceManager.GetResourceGroups.Invoke();

    var exampleGetZones = AliCloud.GetZones.Invoke(new()
    {
        AvailableResourceCreation = "Instance",
    });

    var exampleGetInstanceTypes = AliCloud.Ecs.GetInstanceTypes.Invoke(new()
    {
        AvailabilityZone = exampleGetZones.Apply(getZonesResult => getZonesResult.Zones[0]?.Id),
        CpuCoreCount = 1,
        MemorySize = 2,
    });

    var exampleGetImages = AliCloud.Ecs.GetImages.Invoke(new()
    {
        NameRegex = "^ubuntu_18.*64",
        Owners = "system",
    });

    var exampleNetwork = new AliCloud.Vpc.Network("example", new()
    {
        VpcName = name,
        CidrBlock = "10.4.0.0/16",
    });

    var exampleSwitch = new AliCloud.Vpc.Switch("example", new()
    {
        VswitchName = name,
        CidrBlock = "10.4.0.0/16",
        VpcId = exampleNetwork.Id,
        ZoneId = exampleGetZones.Apply(getZonesResult => getZonesResult.Zones[0]?.Id),
    });

    var exampleSecurityGroup = new AliCloud.Ecs.SecurityGroup("example", new()
    {
        Name = name,
        Description = name,
        VpcId = exampleNetwork.Id,
    });

    var exampleInstance = new AliCloud.Ecs.Instance("example", new()
    {
        AvailabilityZone = exampleGetZones.Apply(getZonesResult => getZonesResult.Zones[0]?.Id),
        InstanceName = name,
        ImageId = exampleGetImages.Apply(getImagesResult => getImagesResult.Images[0]?.Id),
        InstanceType = exampleGetInstanceTypes.Apply(getInstanceTypesResult => getInstanceTypesResult.InstanceTypes[0]?.Id),
        SecurityGroups = new[]
        {
            exampleSecurityGroup.Id,
        },
        VswitchId = exampleSwitch.Id,
    });

    var exampleServerGroup = new AliCloud.Alb.ServerGroup("example", new()
    {
        Protocol = "HTTP",
        VpcId = exampleNetwork.Id,
        ServerGroupName = name,
        ResourceGroupId = example.Apply(getResourceGroupsResult => getResourceGroupsResult.Groups[0]?.Id),
        StickySessionConfig = new AliCloud.Alb.Inputs.ServerGroupStickySessionConfigArgs
        {
            StickySessionEnabled = true,
            Cookie = "tf-example",
            StickySessionType = "Server",
        },
        HealthCheckConfig = new AliCloud.Alb.Inputs.ServerGroupHealthCheckConfigArgs
        {
            HealthCheckConnectPort = 46325,
            HealthCheckEnabled = true,
            HealthCheckHost = "tf-example.com",
            HealthCheckCodes = new[]
            {
                "http_2xx",
                "http_3xx",
                "http_4xx",
            },
            HealthCheckHttpVersion = "HTTP1.1",
            HealthCheckInterval = 2,
            HealthCheckMethod = "HEAD",
            HealthCheckPath = "/tf-example",
            HealthCheckProtocol = "HTTP",
            HealthCheckTimeout = 5,
            HealthyThreshold = 3,
            UnhealthyThreshold = 3,
        },
        Servers = new[]
        {
            new AliCloud.Alb.Inputs.ServerGroupServerArgs
            {
                Description = name,
                Port = 80,
                ServerId = exampleInstance.Id,
                ServerIp = exampleInstance.PrivateIp,
                ServerType = "Ecs",
                Weight = 10,
            },
        },
        Tags = 
        {
            { "Created", "TF" },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.alicloud.resourcemanager.ResourcemanagerFunctions;
import com.pulumi.alicloud.resourcemanager.inputs.GetResourceGroupsArgs;
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.Instance;
import com.pulumi.alicloud.ecs.InstanceArgs;
import com.pulumi.alicloud.alb.ServerGroup;
import com.pulumi.alicloud.alb.ServerGroupArgs;
import com.pulumi.alicloud.alb.inputs.ServerGroupStickySessionConfigArgs;
import com.pulumi.alicloud.alb.inputs.ServerGroupHealthCheckConfigArgs;
import com.pulumi.alicloud.alb.inputs.ServerGroupServerArgs;
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");
        final var example = ResourcemanagerFunctions.getResourceGroups();

        final var exampleGetZones = AlicloudFunctions.getZones(GetZonesArgs.builder()
            .availableResourceCreation("Instance")
            .build());

        final var exampleGetInstanceTypes = EcsFunctions.getInstanceTypes(GetInstanceTypesArgs.builder()
            .availabilityZone(exampleGetZones.applyValue(getZonesResult -> getZonesResult.zones()[0].id()))
            .cpuCoreCount(1)
            .memorySize(2)
            .build());

        final var exampleGetImages = EcsFunctions.getImages(GetImagesArgs.builder()
            .nameRegex("^ubuntu_18.*64")
            .owners("system")
            .build());

        var exampleNetwork = new Network("exampleNetwork", NetworkArgs.builder()
            .vpcName(name)
            .cidrBlock("10.4.0.0/16")
            .build());

        var exampleSwitch = new Switch("exampleSwitch", SwitchArgs.builder()
            .vswitchName(name)
            .cidrBlock("10.4.0.0/16")
            .vpcId(exampleNetwork.id())
            .zoneId(exampleGetZones.applyValue(getZonesResult -> getZonesResult.zones()[0].id()))
            .build());

        var exampleSecurityGroup = new SecurityGroup("exampleSecurityGroup", SecurityGroupArgs.builder()
            .name(name)
            .description(name)
            .vpcId(exampleNetwork.id())
            .build());

        var exampleInstance = new Instance("exampleInstance", InstanceArgs.builder()
            .availabilityZone(exampleGetZones.applyValue(getZonesResult -> getZonesResult.zones()[0].id()))
            .instanceName(name)
            .imageId(exampleGetImages.applyValue(getImagesResult -> getImagesResult.images()[0].id()))
            .instanceType(exampleGetInstanceTypes.applyValue(getInstanceTypesResult -> getInstanceTypesResult.instanceTypes()[0].id()))
            .securityGroups(exampleSecurityGroup.id())
            .vswitchId(exampleSwitch.id())
            .build());

        var exampleServerGroup = new ServerGroup("exampleServerGroup", ServerGroupArgs.builder()
            .protocol("HTTP")
            .vpcId(exampleNetwork.id())
            .serverGroupName(name)
            .resourceGroupId(example.applyValue(getResourceGroupsResult -> getResourceGroupsResult.groups()[0].id()))
            .stickySessionConfig(ServerGroupStickySessionConfigArgs.builder()
                .stickySessionEnabled(true)
                .cookie("tf-example")
                .stickySessionType("Server")
                .build())
            .healthCheckConfig(ServerGroupHealthCheckConfigArgs.builder()
                .healthCheckConnectPort("46325")
                .healthCheckEnabled(true)
                .healthCheckHost("tf-example.com")
                .healthCheckCodes(                
                    "http_2xx",
                    "http_3xx",
                    "http_4xx")
                .healthCheckHttpVersion("HTTP1.1")
                .healthCheckInterval("2")
                .healthCheckMethod("HEAD")
                .healthCheckPath("/tf-example")
                .healthCheckProtocol("HTTP")
                .healthCheckTimeout(5)
                .healthyThreshold(3)
                .unhealthyThreshold(3)
                .build())
            .servers(ServerGroupServerArgs.builder()
                .description(name)
                .port(80)
                .serverId(exampleInstance.id())
                .serverIp(exampleInstance.privateIp())
                .serverType("Ecs")
                .weight(10)
                .build())
            .tags(Map.of("Created", "TF"))
            .build());

    }
}

configuration:
  name:
    type: string
    default: terraform-example
resources:
  exampleNetwork:
    type: alicloud:vpc:Network
    name: example
    properties:
      vpcName: ${name}
      cidrBlock: 10.4.0.0/16
  exampleSwitch:
    type: alicloud:vpc:Switch
    name: example
    properties:
      vswitchName: ${name}
      cidrBlock: 10.4.0.0/16
      vpcId: ${exampleNetwork.id}
      zoneId: ${exampleGetZones.zones[0].id}
  exampleSecurityGroup:
    type: alicloud:ecs:SecurityGroup
    name: example
    properties:
      name: ${name}
      description: ${name}
      vpcId: ${exampleNetwork.id}
  exampleInstance:
    type: alicloud:ecs:Instance
    name: example
    properties:
      availabilityZone: ${exampleGetZones.zones[0].id}
      instanceName: ${name}
      imageId: ${exampleGetImages.images[0].id}
      instanceType: ${exampleGetInstanceTypes.instanceTypes[0].id}
      securityGroups:
        - ${exampleSecurityGroup.id}
      vswitchId: ${exampleSwitch.id}
  exampleServerGroup:
    type: alicloud:alb:ServerGroup
    name: example
    properties:
      protocol: HTTP
      vpcId: ${exampleNetwork.id}
      serverGroupName: ${name}
      resourceGroupId: ${example.groups[0].id}
      stickySessionConfig:
        stickySessionEnabled: true
        cookie: tf-example
        stickySessionType: Server
      healthCheckConfig:
        healthCheckConnectPort: '46325'
        healthCheckEnabled: true
        healthCheckHost: tf-example.com
        healthCheckCodes:
          - http_2xx
          - http_3xx
          - http_4xx
        healthCheckHttpVersion: HTTP1.1
        healthCheckInterval: '2'
        healthCheckMethod: HEAD
        healthCheckPath: /tf-example
        healthCheckProtocol: HTTP
        healthCheckTimeout: 5
        healthyThreshold: 3
        unhealthyThreshold: 3
      servers:
        - description: ${name}
          port: 80
          serverId: ${exampleInstance.id}
          serverIp: ${exampleInstance.privateIp}
          serverType: Ecs
          weight: 10
      tags:
        Created: TF
variables:
  example:
    fn::invoke:
      function: alicloud:resourcemanager:getResourceGroups
      arguments: {}
  exampleGetZones:
    fn::invoke:
      function: alicloud:getZones
      arguments:
        availableResourceCreation: Instance
  exampleGetInstanceTypes:
    fn::invoke:
      function: alicloud:ecs:getInstanceTypes
      arguments:
        availabilityZone: ${exampleGetZones.zones[0].id}
        cpuCoreCount: 1
        memorySize: 2
  exampleGetImages:
    fn::invoke:
      function: alicloud:ecs:getImages
      arguments:
        nameRegex: ^ubuntu_18.*64
        owners: system

var serverGroupResource = new AliCloud.Alb.ServerGroup("serverGroupResource", new()
{
    HealthCheckConfig = new AliCloud.Alb.Inputs.ServerGroupHealthCheckConfigArgs
    {
        HealthCheckEnabled = false,
        HealthCheckCodes = new[]
        {
            "string",
        },
        HealthCheckConnectPort = 0,
        HealthCheckHost = "string",
        HealthCheckHttpVersion = "string",
        HealthCheckInterval = 0,
        HealthCheckMethod = "string",
        HealthCheckPath = "string",
        HealthCheckProtocol = "string",
        HealthCheckTimeout = 0,
        HealthyThreshold = 0,
        UnhealthyThreshold = 0,
    },
    ServerGroupName = "string",
    Scheduler = "string",
    Servers = new[]
    {
        new AliCloud.Alb.Inputs.ServerGroupServerArgs
        {
            ServerId = "string",
            ServerType = "string",
            Description = "string",
            Port = 0,
            RemoteIpEnabled = false,
            ServerGroupId = "string",
            ServerIp = "string",
            Status = "string",
            Weight = 0,
        },
    },
    HealthCheckTemplateId = "string",
    Ipv6Enabled = false,
    Protocol = "string",
    ResourceGroupId = "string",
    ConnectionDrainConfig = new AliCloud.Alb.Inputs.ServerGroupConnectionDrainConfigArgs
    {
        ConnectionDrainEnabled = false,
        ConnectionDrainTimeout = 0,
    },
    CrossZoneEnabled = false,
    ServerGroupType = "string",
    DryRun = false,
    ServiceName = "string",
    SlowStartConfig = new AliCloud.Alb.Inputs.ServerGroupSlowStartConfigArgs
    {
        SlowStartDuration = 0,
        SlowStartEnabled = false,
    },
    StickySessionConfig = new AliCloud.Alb.Inputs.ServerGroupStickySessionConfigArgs
    {
        Cookie = "string",
        CookieTimeout = 0,
        StickySessionEnabled = false,
        StickySessionType = "string",
    },
    Tags = 
    {
        { "string", "string" },
    },
    UchConfig = new AliCloud.Alb.Inputs.ServerGroupUchConfigArgs
    {
        Type = "string",
        Value = "string",
    },
    UpstreamKeepaliveEnabled = false,
    VpcId = "string",
});

example, err := alb.NewServerGroup(ctx, "serverGroupResource", &alb.ServerGroupArgs{
	HealthCheckConfig: &alb.ServerGroupHealthCheckConfigArgs{
		HealthCheckEnabled: pulumi.Bool(false),
		HealthCheckCodes: pulumi.StringArray{
			pulumi.String("string"),
		},
		HealthCheckConnectPort: pulumi.Int(0),
		HealthCheckHost:        pulumi.String("string"),
		HealthCheckHttpVersion: pulumi.String("string"),
		HealthCheckInterval:    pulumi.Int(0),
		HealthCheckMethod:      pulumi.String("string"),
		HealthCheckPath:        pulumi.String("string"),
		HealthCheckProtocol:    pulumi.String("string"),
		HealthCheckTimeout:     pulumi.Int(0),
		HealthyThreshold:       pulumi.Int(0),
		UnhealthyThreshold:     pulumi.Int(0),
	},
	ServerGroupName: pulumi.String("string"),
	Scheduler:       pulumi.String("string"),
	Servers: alb.ServerGroupServerArray{
		&alb.ServerGroupServerArgs{
			ServerId:        pulumi.String("string"),
			ServerType:      pulumi.String("string"),
			Description:     pulumi.String("string"),
			Port:            pulumi.Int(0),
			RemoteIpEnabled: pulumi.Bool(false),
			ServerGroupId:   pulumi.String("string"),
			ServerIp:        pulumi.String("string"),
			Status:          pulumi.String("string"),
			Weight:          pulumi.Int(0),
		},
	},
	HealthCheckTemplateId: pulumi.String("string"),
	Ipv6Enabled:           pulumi.Bool(false),
	Protocol:              pulumi.String("string"),
	ResourceGroupId:       pulumi.String("string"),
	ConnectionDrainConfig: &alb.ServerGroupConnectionDrainConfigArgs{
		ConnectionDrainEnabled: pulumi.Bool(false),
		ConnectionDrainTimeout: pulumi.Int(0),
	},
	CrossZoneEnabled: pulumi.Bool(false),
	ServerGroupType:  pulumi.String("string"),
	DryRun:           pulumi.Bool(false),
	ServiceName:      pulumi.String("string"),
	SlowStartConfig: &alb.ServerGroupSlowStartConfigArgs{
		SlowStartDuration: pulumi.Int(0),
		SlowStartEnabled:  pulumi.Bool(false),
	},
	StickySessionConfig: &alb.ServerGroupStickySessionConfigArgs{
		Cookie:               pulumi.String("string"),
		CookieTimeout:        pulumi.Int(0),
		StickySessionEnabled: pulumi.Bool(false),
		StickySessionType:    pulumi.String("string"),
	},
	Tags: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	UchConfig: &alb.ServerGroupUchConfigArgs{
		Type:  pulumi.String("string"),
		Value: pulumi.String("string"),
	},
	UpstreamKeepaliveEnabled: pulumi.Bool(false),
	VpcId:                    pulumi.String("string"),
})

var serverGroupResource = new ServerGroup("serverGroupResource", ServerGroupArgs.builder()
    .healthCheckConfig(ServerGroupHealthCheckConfigArgs.builder()
        .healthCheckEnabled(false)
        .healthCheckCodes("string")
        .healthCheckConnectPort(0)
        .healthCheckHost("string")
        .healthCheckHttpVersion("string")
        .healthCheckInterval(0)
        .healthCheckMethod("string")
        .healthCheckPath("string")
        .healthCheckProtocol("string")
        .healthCheckTimeout(0)
        .healthyThreshold(0)
        .unhealthyThreshold(0)
        .build())
    .serverGroupName("string")
    .scheduler("string")
    .servers(ServerGroupServerArgs.builder()
        .serverId("string")
        .serverType("string")
        .description("string")
        .port(0)
        .remoteIpEnabled(false)
        .serverGroupId("string")
        .serverIp("string")
        .status("string")
        .weight(0)
        .build())
    .healthCheckTemplateId("string")
    .ipv6Enabled(false)
    .protocol("string")
    .resourceGroupId("string")
    .connectionDrainConfig(ServerGroupConnectionDrainConfigArgs.builder()
        .connectionDrainEnabled(false)
        .connectionDrainTimeout(0)
        .build())
    .crossZoneEnabled(false)
    .serverGroupType("string")
    .dryRun(false)
    .serviceName("string")
    .slowStartConfig(ServerGroupSlowStartConfigArgs.builder()
        .slowStartDuration(0)
        .slowStartEnabled(false)
        .build())
    .stickySessionConfig(ServerGroupStickySessionConfigArgs.builder()
        .cookie("string")
        .cookieTimeout(0)
        .stickySessionEnabled(false)
        .stickySessionType("string")
        .build())
    .tags(Map.of("string", "string"))
    .uchConfig(ServerGroupUchConfigArgs.builder()
        .type("string")
        .value("string")
        .build())
    .upstreamKeepaliveEnabled(false)
    .vpcId("string")
    .build());

server_group_resource = alicloud.alb.ServerGroup("serverGroupResource",
    health_check_config={
        "health_check_enabled": False,
        "health_check_codes": ["string"],
        "health_check_connect_port": 0,
        "health_check_host": "string",
        "health_check_http_version": "string",
        "health_check_interval": 0,
        "health_check_method": "string",
        "health_check_path": "string",
        "health_check_protocol": "string",
        "health_check_timeout": 0,
        "healthy_threshold": 0,
        "unhealthy_threshold": 0,
    },
    server_group_name="string",
    scheduler="string",
    servers=[{
        "server_id": "string",
        "server_type": "string",
        "description": "string",
        "port": 0,
        "remote_ip_enabled": False,
        "server_group_id": "string",
        "server_ip": "string",
        "status": "string",
        "weight": 0,
    }],
    health_check_template_id="string",
    ipv6_enabled=False,
    protocol="string",
    resource_group_id="string",
    connection_drain_config={
        "connection_drain_enabled": False,
        "connection_drain_timeout": 0,
    },
    cross_zone_enabled=False,
    server_group_type="string",
    dry_run=False,
    service_name="string",
    slow_start_config={
        "slow_start_duration": 0,
        "slow_start_enabled": False,
    },
    sticky_session_config={
        "cookie": "string",
        "cookie_timeout": 0,
        "sticky_session_enabled": False,
        "sticky_session_type": "string",
    },
    tags={
        "string": "string",
    },
    uch_config={
        "type": "string",
        "value": "string",
    },
    upstream_keepalive_enabled=False,
    vpc_id="string")

const serverGroupResource = new alicloud.alb.ServerGroup("serverGroupResource", {
    healthCheckConfig: {
        healthCheckEnabled: false,
        healthCheckCodes: ["string"],
        healthCheckConnectPort: 0,
        healthCheckHost: "string",
        healthCheckHttpVersion: "string",
        healthCheckInterval: 0,
        healthCheckMethod: "string",
        healthCheckPath: "string",
        healthCheckProtocol: "string",
        healthCheckTimeout: 0,
        healthyThreshold: 0,
        unhealthyThreshold: 0,
    },
    serverGroupName: "string",
    scheduler: "string",
    servers: [{
        serverId: "string",
        serverType: "string",
        description: "string",
        port: 0,
        remoteIpEnabled: false,
        serverGroupId: "string",
        serverIp: "string",
        status: "string",
        weight: 0,
    }],
    healthCheckTemplateId: "string",
    ipv6Enabled: false,
    protocol: "string",
    resourceGroupId: "string",
    connectionDrainConfig: {
        connectionDrainEnabled: false,
        connectionDrainTimeout: 0,
    },
    crossZoneEnabled: false,
    serverGroupType: "string",
    dryRun: false,
    serviceName: "string",
    slowStartConfig: {
        slowStartDuration: 0,
        slowStartEnabled: false,
    },
    stickySessionConfig: {
        cookie: "string",
        cookieTimeout: 0,
        stickySessionEnabled: false,
        stickySessionType: "string",
    },
    tags: {
        string: "string",
    },
    uchConfig: {
        type: "string",
        value: "string",
    },
    upstreamKeepaliveEnabled: false,
    vpcId: "string",
});

type: alicloud:alb:ServerGroup
properties:
    connectionDrainConfig:
        connectionDrainEnabled: false
        connectionDrainTimeout: 0
    crossZoneEnabled: false
    dryRun: false
    healthCheckConfig:
        healthCheckCodes:
            - string
        healthCheckConnectPort: 0
        healthCheckEnabled: false
        healthCheckHost: string
        healthCheckHttpVersion: string
        healthCheckInterval: 0
        healthCheckMethod: string
        healthCheckPath: string
        healthCheckProtocol: string
        healthCheckTimeout: 0
        healthyThreshold: 0
        unhealthyThreshold: 0
    healthCheckTemplateId: string
    ipv6Enabled: false
    protocol: string
    resourceGroupId: string
    scheduler: string
    serverGroupName: string
    serverGroupType: string
    servers:
        - description: string
          port: 0
          remoteIpEnabled: false
          serverGroupId: string
          serverId: string
          serverIp: string
          serverType: string
          status: string
          weight: 0
    serviceName: string
    slowStartConfig:
        slowStartDuration: 0
        slowStartEnabled: false
    stickySessionConfig:
        cookie: string
        cookieTimeout: 0
        stickySessionEnabled: false
        stickySessionType: string
    tags:
        string: string
    uchConfig:
        type: string
        value: string
    upstreamKeepaliveEnabled: false
    vpcId: string