pulumi-alicloud-kotlin/com.pulumi.alicloud.slb.kotlin/ServerGroupArgs

ServerGroupArgs

data class ServerGroupArgs(val deleteProtectionValidation: Output<Boolean>? = null, val loadBalancerId: Output<String>? = null, val name: Output<String>? = null, val servers: Output<List<ServerGroupServerArgs>>? = null) : ConvertibleToJava<ServerGroupArgs>

A virtual server group contains several ECS instances. The virtual server group can help you to define multiple listening dimension, and to meet the personalized requirements of domain name and URL forwarding.

NOTE: Available since v1.6.0. NOTE: One ECS instance can be added into multiple virtual server groups. NOTE: One virtual server group can be attached with multiple listeners in one load balancer. NOTE: One Classic and Internet load balancer, its virtual server group can add Classic and VPC ECS instances. NOTE: One Classic and Intranet load balancer, its virtual server group can only add Classic ECS instances. NOTE: One VPC load balancer, its virtual server group can only add the same VPC ECS instances. For information about server group and how to use it, see Configure a server group.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as alicloud from "@pulumi/alicloud";
const config = new pulumi.Config();
const slbServerGroupName = config.get("slbServerGroupName") || "forSlbServerGroup";
const serverGroup = alicloud.getZones({
    availableResourceCreation: "VSwitch",
});
const serverGroupNetwork = new alicloud.vpc.Network("server_group", {
    vpcName: slbServerGroupName,
    cidrBlock: "172.16.0.0/16",
});
const serverGroupSwitch = new alicloud.vpc.Switch("server_group", {
    vpcId: serverGroupNetwork.id,
    cidrBlock: "172.16.0.0/16",
    zoneId: serverGroup.then(serverGroup => serverGroup.zones?.[0]?.id),
    vswitchName: slbServerGroupName,
});
const serverGroupApplicationLoadBalancer = new alicloud.slb.ApplicationLoadBalancer("server_group", {
    loadBalancerName: slbServerGroupName,
    vswitchId: serverGroupSwitch.id,
    instanceChargeType: "PayByCLCU",
});
const serverGroupServerGroup = new alicloud.slb.ServerGroup("server_group", {
    loadBalancerId: serverGroupApplicationLoadBalancer.id,
    name: slbServerGroupName,
});
Content copied to clipboard
import pulumi
import pulumi_alicloud as alicloud
config = pulumi.Config()
slb_server_group_name = config.get("slbServerGroupName")
if slb_server_group_name is None:
    slb_server_group_name = "forSlbServerGroup"
server_group = alicloud.get_zones(available_resource_creation="VSwitch")
server_group_network = alicloud.vpc.Network("server_group",
    vpc_name=slb_server_group_name,
    cidr_block="172.16.0.0/16")
server_group_switch = alicloud.vpc.Switch("server_group",
    vpc_id=server_group_network.id,
    cidr_block="172.16.0.0/16",
    zone_id=server_group.zones[0].id,
    vswitch_name=slb_server_group_name)
server_group_application_load_balancer = alicloud.slb.ApplicationLoadBalancer("server_group",
    load_balancer_name=slb_server_group_name,
    vswitch_id=server_group_switch.id,
    instance_charge_type="PayByCLCU")
server_group_server_group = alicloud.slb.ServerGroup("server_group",
    load_balancer_id=server_group_application_load_balancer.id,
    name=slb_server_group_name)
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AliCloud = Pulumi.AliCloud;
return await Deployment.RunAsync(() =>
{
    var config = new Config();
    var slbServerGroupName = config.Get("slbServerGroupName") ?? "forSlbServerGroup";
    var serverGroup = AliCloud.GetZones.Invoke(new()
    {
        AvailableResourceCreation = "VSwitch",
    });
    var serverGroupNetwork = new AliCloud.Vpc.Network("server_group", new()
    {
        VpcName = slbServerGroupName,
        CidrBlock = "172.16.0.0/16",
    });
    var serverGroupSwitch = new AliCloud.Vpc.Switch("server_group", new()
    {
        VpcId = serverGroupNetwork.Id,
        CidrBlock = "172.16.0.0/16",
        ZoneId = serverGroup.Apply(getZonesResult => getZonesResult.Zones[0]?.Id),
        VswitchName = slbServerGroupName,
    });
    var serverGroupApplicationLoadBalancer = new AliCloud.Slb.ApplicationLoadBalancer("server_group", new()
    {
        LoadBalancerName = slbServerGroupName,
        VswitchId = serverGroupSwitch.Id,
        InstanceChargeType = "PayByCLCU",
    });
    var serverGroupServerGroup = new AliCloud.Slb.ServerGroup("server_group", new()
    {
        LoadBalancerId = serverGroupApplicationLoadBalancer.Id,
        Name = slbServerGroupName,
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/slb"
	"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, "")
		slbServerGroupName := "forSlbServerGroup"
		if param := cfg.Get("slbServerGroupName"); param != "" {
			slbServerGroupName = param
		}
		serverGroup, err := alicloud.GetZones(ctx, &alicloud.GetZonesArgs{
			AvailableResourceCreation: pulumi.StringRef("VSwitch"),
		}, nil)
		if err != nil {
			return err
		}
		serverGroupNetwork, err := vpc.NewNetwork(ctx, "server_group", &vpc.NetworkArgs{
			VpcName:   pulumi.String(slbServerGroupName),
			CidrBlock: pulumi.String("172.16.0.0/16"),
		})
		if err != nil {
			return err
		}
		serverGroupSwitch, err := vpc.NewSwitch(ctx, "server_group", &vpc.SwitchArgs{
			VpcId:       serverGroupNetwork.ID(),
			CidrBlock:   pulumi.String("172.16.0.0/16"),
			ZoneId:      pulumi.String(serverGroup.Zones[0].Id),
			VswitchName: pulumi.String(slbServerGroupName),
		})
		if err != nil {
			return err
		}
		serverGroupApplicationLoadBalancer, err := slb.NewApplicationLoadBalancer(ctx, "server_group", &slb.ApplicationLoadBalancerArgs{
			LoadBalancerName:   pulumi.String(slbServerGroupName),
			VswitchId:          serverGroupSwitch.ID(),
			InstanceChargeType: pulumi.String("PayByCLCU"),
		})
		if err != nil {
			return err
		}
		_, err = slb.NewServerGroup(ctx, "server_group", &slb.ServerGroupArgs{
			LoadBalancerId: serverGroupApplicationLoadBalancer.ID(),
			Name:           pulumi.String(slbServerGroupName),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.alicloud.AlicloudFunctions;
import com.pulumi.alicloud.inputs.GetZonesArgs;
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.slb.ApplicationLoadBalancer;
import com.pulumi.alicloud.slb.ApplicationLoadBalancerArgs;
import com.pulumi.alicloud.slb.ServerGroup;
import com.pulumi.alicloud.slb.ServerGroupArgs;
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 slbServerGroupName = config.get("slbServerGroupName").orElse("forSlbServerGroup");
        final var serverGroup = AlicloudFunctions.getZones(GetZonesArgs.builder()
            .availableResourceCreation("VSwitch")
            .build());
        var serverGroupNetwork = new Network("serverGroupNetwork", NetworkArgs.builder()
            .vpcName(slbServerGroupName)
            .cidrBlock("172.16.0.0/16")
            .build());
        var serverGroupSwitch = new Switch("serverGroupSwitch", SwitchArgs.builder()
            .vpcId(serverGroupNetwork.id())
            .cidrBlock("172.16.0.0/16")
            .zoneId(serverGroup.applyValue(getZonesResult -> getZonesResult.zones()[0].id()))
            .vswitchName(slbServerGroupName)
            .build());
        var serverGroupApplicationLoadBalancer = new ApplicationLoadBalancer("serverGroupApplicationLoadBalancer", ApplicationLoadBalancerArgs.builder()
            .loadBalancerName(slbServerGroupName)
            .vswitchId(serverGroupSwitch.id())
            .instanceChargeType("PayByCLCU")
            .build());
        var serverGroupServerGroup = new ServerGroup("serverGroupServerGroup", ServerGroupArgs.builder()
            .loadBalancerId(serverGroupApplicationLoadBalancer.id())
            .name(slbServerGroupName)
            .build());
    }
}
Content copied to clipboard
configuration:
  slbServerGroupName:
    type: string
    default: forSlbServerGroup
resources:
  serverGroupNetwork:
    type: alicloud:vpc:Network
    name: server_group
    properties:
      vpcName: ${slbServerGroupName}
      cidrBlock: 172.16.0.0/16
  serverGroupSwitch:
    type: alicloud:vpc:Switch
    name: server_group
    properties:
      vpcId: ${serverGroupNetwork.id}
      cidrBlock: 172.16.0.0/16
      zoneId: ${serverGroup.zones[0].id}
      vswitchName: ${slbServerGroupName}
  serverGroupApplicationLoadBalancer:
    type: alicloud:slb:ApplicationLoadBalancer
    name: server_group
    properties:
      loadBalancerName: ${slbServerGroupName}
      vswitchId: ${serverGroupSwitch.id}
      instanceChargeType: PayByCLCU
  serverGroupServerGroup:
    type: alicloud:slb:ServerGroup
    name: server_group
    properties:
      loadBalancerId: ${serverGroupApplicationLoadBalancer.id}
      name: ${slbServerGroupName}
variables:
  serverGroup:
    fn::invoke:
      Function: alicloud:getZones
      Arguments:
        availableResourceCreation: VSwitch
Content copied to clipboard

Import

Load balancer backend server group can be imported using the id, e.g.

$ pulumi import alicloud:slb/serverGroup:ServerGroup example abc123456
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(deleteProtectionValidation: Output<Boolean>? = null, loadBalancerId: Output<String>? = null, name: Output<String>? = null, servers: Output<List<ServerGroupServerArgs>>? = null)

Properties

Link copied to clipboard
val deleteProtectionValidation: Output<Boolean>? = null

Checking DeleteProtection of SLB instance before deleting. If true, this resource will not be deleted when its SLB instance enabled DeleteProtection. Default to false.

Link copied to clipboard
val loadBalancerId: Output<String>? = null

The Load Balancer ID which is used to launch a new virtual server group.

Link copied to clipboard
val name: Output<String>? = null

Name of the virtual server group. Our plugin provides a default name: "tf-server-group".

Link copied to clipboard
val servers: Output<List<ServerGroupServerArgs>>? = null

A list of ECS instances to be added. NOTE: Field 'servers' has been deprecated from provider version 1.163.0 and it will be removed in the future version. Please use the new resource 'alicloud_slb_server_group_server_attachment'. At most 20 ECS instances can be supported in one resource. It contains three sub-fields as Block server follows. See servers below for details.

Functions

Link copied to clipboard
open override fun toJava(): ServerGroupArgs