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_[0-9]+_[0-9]+_x64*",
    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_[0-9]+_[0-9]+_x64*",
    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=alicloud.alb.ServerGroupStickySessionConfigArgs(
        sticky_session_enabled=True,
        cookie="tf-example",
        sticky_session_type="Server",
    ),
    health_check_config=alicloud.alb.ServerGroupHealthCheckConfigArgs(
        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=[alicloud.alb.ServerGroupServerArgs(
        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, nil, 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_[0-9]+_[0-9]+_x64*"),
			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.Map{
				"Created": pulumi.Any("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_[0-9]+_[0-9]+_x64*",
        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_[0-9]+_[0-9]+_x64*")
            .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_[0-9]+_[0-9]+_x64*
        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",
    DryRun = false,
    Protocol = "string",
    ResourceGroupId = "string",
    Scheduler = "string",
    ServerGroupType = "string",
    Servers = new[]
    {
        new AliCloud.Alb.Inputs.ServerGroupServerArgs
        {
            ServerId = "string",
            ServerType = "string",
            Description = "string",
            Port = 0,
            RemoteIpEnabled = false,
            ServerIp = "string",
            Status = "string",
            Weight = 0,
        },
    },
    StickySessionConfig = new AliCloud.Alb.Inputs.ServerGroupStickySessionConfigArgs
    {
        Cookie = "string",
        CookieTimeout = 0,
        StickySessionEnabled = false,
        StickySessionType = "string",
    },
    Tags = 
    {
        { "string", "any" },
    },
    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"),
	DryRun:          pulumi.Bool(false),
	Protocol:        pulumi.String("string"),
	ResourceGroupId: pulumi.String("string"),
	Scheduler:       pulumi.String("string"),
	ServerGroupType: 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),
			ServerIp:        pulumi.String("string"),
			Status:          pulumi.String("string"),
			Weight:          pulumi.Int(0),
		},
	},
	StickySessionConfig: &alb.ServerGroupStickySessionConfigArgs{
		Cookie:               pulumi.String("string"),
		CookieTimeout:        pulumi.Int(0),
		StickySessionEnabled: pulumi.Bool(false),
		StickySessionType:    pulumi.String("string"),
	},
	Tags: pulumi.Map{
		"string": pulumi.Any("any"),
	},
	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")
    .dryRun(false)
    .protocol("string")
    .resourceGroupId("string")
    .scheduler("string")
    .serverGroupType("string")
    .servers(ServerGroupServerArgs.builder()
        .serverId("string")
        .serverType("string")
        .description("string")
        .port(0)
        .remoteIpEnabled(false)
        .serverIp("string")
        .status("string")
        .weight(0)
        .build())
    .stickySessionConfig(ServerGroupStickySessionConfigArgs.builder()
        .cookie("string")
        .cookieTimeout(0)
        .stickySessionEnabled(false)
        .stickySessionType("string")
        .build())
    .tags(Map.of("string", "any"))
    .vpcId("string")
    .build());

server_group_resource = alicloud.alb.ServerGroup("serverGroupResource",
    health_check_config=alicloud.alb.ServerGroupHealthCheckConfigArgs(
        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",
    dry_run=False,
    protocol="string",
    resource_group_id="string",
    scheduler="string",
    server_group_type="string",
    servers=[alicloud.alb.ServerGroupServerArgs(
        server_id="string",
        server_type="string",
        description="string",
        port=0,
        remote_ip_enabled=False,
        server_ip="string",
        status="string",
        weight=0,
    )],
    sticky_session_config=alicloud.alb.ServerGroupStickySessionConfigArgs(
        cookie="string",
        cookie_timeout=0,
        sticky_session_enabled=False,
        sticky_session_type="string",
    ),
    tags={
        "string": "any",
    },
    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",
    dryRun: false,
    protocol: "string",
    resourceGroupId: "string",
    scheduler: "string",
    serverGroupType: "string",
    servers: [{
        serverId: "string",
        serverType: "string",
        description: "string",
        port: 0,
        remoteIpEnabled: false,
        serverIp: "string",
        status: "string",
        weight: 0,
    }],
    stickySessionConfig: {
        cookie: "string",
        cookieTimeout: 0,
        stickySessionEnabled: false,
        stickySessionType: "string",
    },
    tags: {
        string: "any",
    },
    vpcId: "string",
});

type: alicloud:alb:ServerGroup
properties:
    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
    protocol: string
    resourceGroupId: string
    scheduler: string
    serverGroupName: string
    serverGroupType: string
    servers:
        - description: string
          port: 0
          remoteIpEnabled: false
          serverId: string
          serverIp: string
          serverType: string
          status: string
          weight: 0
    stickySessionConfig:
        cookie: string
        cookieTimeout: 0
        stickySessionEnabled: false
        stickySessionType: string
    tags:
        string: any
    vpcId: string