volcengine.alb.ServerGroup

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

return await Deployment.RunAsync(() => 
{
    var fooVpc = new Volcengine.Vpc.Vpc("fooVpc", new()
    {
        VpcName = "acc-test-vpc",
        CidrBlock = "172.16.0.0/16",
    });

    var fooServerGroup = new Volcengine.Alb.ServerGroup("fooServerGroup", new()
    {
        VpcId = fooVpc.Id,
        ServerGroupName = "acc-test-server-group",
        Description = "acc-test",
        ServerGroupType = "instance",
        Scheduler = "wlc",
        ProjectName = "default",
        HealthCheck = new Volcengine.Alb.Inputs.ServerGroupHealthCheckArgs
        {
            Enabled = "on",
            Interval = 3,
            Timeout = 3,
            Method = "GET",
        },
        StickySessionConfig = new Volcengine.Alb.Inputs.ServerGroupStickySessionConfigArgs
        {
            StickySessionEnabled = "on",
            StickySessionType = "insert",
            CookieTimeout = 1100,
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/alb"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/vpc"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		fooVpc, err := vpc.NewVpc(ctx, "fooVpc", &vpc.VpcArgs{
			VpcName:   pulumi.String("acc-test-vpc"),
			CidrBlock: pulumi.String("172.16.0.0/16"),
		})
		if err != nil {
			return err
		}
		_, err = alb.NewServerGroup(ctx, "fooServerGroup", &alb.ServerGroupArgs{
			VpcId:           fooVpc.ID(),
			ServerGroupName: pulumi.String("acc-test-server-group"),
			Description:     pulumi.String("acc-test"),
			ServerGroupType: pulumi.String("instance"),
			Scheduler:       pulumi.String("wlc"),
			ProjectName:     pulumi.String("default"),
			HealthCheck: &alb.ServerGroupHealthCheckArgs{
				Enabled:  pulumi.String("on"),
				Interval: pulumi.Int(3),
				Timeout:  pulumi.Int(3),
				Method:   pulumi.String("GET"),
			},
			StickySessionConfig: &alb.ServerGroupStickySessionConfigArgs{
				StickySessionEnabled: pulumi.String("on"),
				StickySessionType:    pulumi.String("insert"),
				CookieTimeout:        pulumi.Int(1100),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.volcengine.vpc.Vpc;
import com.pulumi.volcengine.vpc.VpcArgs;
import com.pulumi.volcengine.alb.ServerGroup;
import com.pulumi.volcengine.alb.ServerGroupArgs;
import com.pulumi.volcengine.alb.inputs.ServerGroupHealthCheckArgs;
import com.pulumi.volcengine.alb.inputs.ServerGroupStickySessionConfigArgs;
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) {
        var fooVpc = new Vpc("fooVpc", VpcArgs.builder()        
            .vpcName("acc-test-vpc")
            .cidrBlock("172.16.0.0/16")
            .build());

        var fooServerGroup = new ServerGroup("fooServerGroup", ServerGroupArgs.builder()        
            .vpcId(fooVpc.id())
            .serverGroupName("acc-test-server-group")
            .description("acc-test")
            .serverGroupType("instance")
            .scheduler("wlc")
            .projectName("default")
            .healthCheck(ServerGroupHealthCheckArgs.builder()
                .enabled("on")
                .interval(3)
                .timeout(3)
                .method("GET")
                .build())
            .stickySessionConfig(ServerGroupStickySessionConfigArgs.builder()
                .stickySessionEnabled("on")
                .stickySessionType("insert")
                .cookieTimeout("1100")
                .build())
            .build());

    }
}

import pulumi
import pulumi_volcengine as volcengine

foo_vpc = volcengine.vpc.Vpc("fooVpc",
    vpc_name="acc-test-vpc",
    cidr_block="172.16.0.0/16")
foo_server_group = volcengine.alb.ServerGroup("fooServerGroup",
    vpc_id=foo_vpc.id,
    server_group_name="acc-test-server-group",
    description="acc-test",
    server_group_type="instance",
    scheduler="wlc",
    project_name="default",
    health_check=volcengine.alb.ServerGroupHealthCheckArgs(
        enabled="on",
        interval=3,
        timeout=3,
        method="GET",
    ),
    sticky_session_config=volcengine.alb.ServerGroupStickySessionConfigArgs(
        sticky_session_enabled="on",
        sticky_session_type="insert",
        cookie_timeout=1100,
    ))

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

const fooVpc = new volcengine.vpc.Vpc("fooVpc", {
    vpcName: "acc-test-vpc",
    cidrBlock: "172.16.0.0/16",
});
const fooServerGroup = new volcengine.alb.ServerGroup("fooServerGroup", {
    vpcId: fooVpc.id,
    serverGroupName: "acc-test-server-group",
    description: "acc-test",
    serverGroupType: "instance",
    scheduler: "wlc",
    projectName: "default",
    healthCheck: {
        enabled: "on",
        interval: 3,
        timeout: 3,
        method: "GET",
    },
    stickySessionConfig: {
        stickySessionEnabled: "on",
        stickySessionType: "insert",
        cookieTimeout: 1100,
    },
});

resources:
  fooVpc:
    type: volcengine:vpc:Vpc
    properties:
      vpcName: acc-test-vpc
      cidrBlock: 172.16.0.0/16
  fooServerGroup:
    type: volcengine:alb:ServerGroup
    properties:
      vpcId: ${fooVpc.id}
      serverGroupName: acc-test-server-group
      description: acc-test
      serverGroupType: instance
      scheduler: wlc
      projectName: default
      healthCheck:
        enabled: on
        interval: 3
        timeout: 3
        method: GET
      stickySessionConfig:
        stickySessionEnabled: on
        stickySessionType: insert
        cookieTimeout: '1100'