volcengine.clb.Clb

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

const fooZones = volcengine.ecs.getZones({});
// create vpc
const fooVpc = new volcengine.vpc.Vpc("fooVpc", {
    vpcName: "acc-test-vpc",
    cidrBlock: "172.16.0.0/16",
});
// create subnet
const fooSubnet = new volcengine.vpc.Subnet("fooSubnet", {
    subnetName: "acc-test-subnet",
    cidrBlock: "172.16.0.0/24",
    zoneId: fooZones.then(fooZones => fooZones.zones?.[0]?.id),
    vpcId: fooVpc.id,
});
// create ipv4 public clb
const publicClb = new volcengine.clb.Clb("publicClb", {
    type: "public",
    subnetId: fooSubnet.id,
    loadBalancerName: "acc-test-clb-public",
    loadBalancerSpec: "small_1",
    description: "acc-test-demo",
    projectName: "default",
    eipBillingConfig: {
        isp: "BGP",
        eipBillingType: "PostPaidByBandwidth",
        bandwidth: 1,
    },
    tags: [{
        key: "k1",
        value: "v1",
    }],
});
// create ipv4 private clb
const privateClb = new volcengine.clb.Clb("privateClb", {
    type: "private",
    subnetId: fooSubnet.id,
    loadBalancerName: "acc-test-clb-private",
    loadBalancerSpec: "small_1",
    description: "acc-test-demo",
    projectName: "default",
});
// create eip
const eip = new volcengine.eip.Address("eip", {
    billingType: "PostPaidByBandwidth",
    bandwidth: 1,
    isp: "BGP",
    description: "tf-test",
    projectName: "default",
});
// associate eip to clb
const associate = new volcengine.eip.Associate("associate", {
    allocationId: eip.id,
    instanceId: privateClb.id,
    instanceType: "ClbInstance",
});
// create ipv6 vpc
const vpcIpv6 = new volcengine.vpc.Vpc("vpcIpv6", {
    vpcName: "acc-test-vpc-ipv6",
    cidrBlock: "172.16.0.0/16",
    enableIpv6: true,
});
// create ipv6 subnet
const subnetIpv6 = new volcengine.vpc.Subnet("subnetIpv6", {
    subnetName: "acc-test-subnet-ipv6",
    cidrBlock: "172.16.0.0/24",
    zoneId: fooZones.then(fooZones => fooZones.zones?.[1]?.id),
    vpcId: vpcIpv6.id,
    ipv6CidrBlock: 1,
});
// create ipv6 private clb
const privateClbIpv6 = new volcengine.clb.Clb("privateClbIpv6", {
    type: "private",
    subnetId: subnetIpv6.id,
    loadBalancerName: "acc-test-clb-ipv6",
    loadBalancerSpec: "small_1",
    description: "acc-test-demo",
    projectName: "default",
    addressIpVersion: "DualStack",
});
// create ipv6 gateway
const ipv6Gateway = new volcengine.vpc.Ipv6Gateway("ipv6Gateway", {vpcId: vpcIpv6.id});
const fooIpv6AddressBandwidth = new volcengine.vpc.Ipv6AddressBandwidth("fooIpv6AddressBandwidth", {
    ipv6Address: privateClbIpv6.eniIpv6Address,
    billingType: "PostPaidByBandwidth",
    bandwidth: 5,
}, {
    dependsOn: [ipv6Gateway],
});

import pulumi
import pulumi_volcengine as volcengine

foo_zones = volcengine.ecs.get_zones()
# create vpc
foo_vpc = volcengine.vpc.Vpc("fooVpc",
    vpc_name="acc-test-vpc",
    cidr_block="172.16.0.0/16")
# create subnet
foo_subnet = volcengine.vpc.Subnet("fooSubnet",
    subnet_name="acc-test-subnet",
    cidr_block="172.16.0.0/24",
    zone_id=foo_zones.zones[0].id,
    vpc_id=foo_vpc.id)
# create ipv4 public clb
public_clb = volcengine.clb.Clb("publicClb",
    type="public",
    subnet_id=foo_subnet.id,
    load_balancer_name="acc-test-clb-public",
    load_balancer_spec="small_1",
    description="acc-test-demo",
    project_name="default",
    eip_billing_config=volcengine.clb.ClbEipBillingConfigArgs(
        isp="BGP",
        eip_billing_type="PostPaidByBandwidth",
        bandwidth=1,
    ),
    tags=[volcengine.clb.ClbTagArgs(
        key="k1",
        value="v1",
    )])
# create ipv4 private clb
private_clb = volcengine.clb.Clb("privateClb",
    type="private",
    subnet_id=foo_subnet.id,
    load_balancer_name="acc-test-clb-private",
    load_balancer_spec="small_1",
    description="acc-test-demo",
    project_name="default")
# create eip
eip = volcengine.eip.Address("eip",
    billing_type="PostPaidByBandwidth",
    bandwidth=1,
    isp="BGP",
    description="tf-test",
    project_name="default")
# associate eip to clb
associate = volcengine.eip.Associate("associate",
    allocation_id=eip.id,
    instance_id=private_clb.id,
    instance_type="ClbInstance")
# create ipv6 vpc
vpc_ipv6 = volcengine.vpc.Vpc("vpcIpv6",
    vpc_name="acc-test-vpc-ipv6",
    cidr_block="172.16.0.0/16",
    enable_ipv6=True)
# create ipv6 subnet
subnet_ipv6 = volcengine.vpc.Subnet("subnetIpv6",
    subnet_name="acc-test-subnet-ipv6",
    cidr_block="172.16.0.0/24",
    zone_id=foo_zones.zones[1].id,
    vpc_id=vpc_ipv6.id,
    ipv6_cidr_block=1)
# create ipv6 private clb
private_clb_ipv6 = volcengine.clb.Clb("privateClbIpv6",
    type="private",
    subnet_id=subnet_ipv6.id,
    load_balancer_name="acc-test-clb-ipv6",
    load_balancer_spec="small_1",
    description="acc-test-demo",
    project_name="default",
    address_ip_version="DualStack")
# create ipv6 gateway
ipv6_gateway = volcengine.vpc.Ipv6Gateway("ipv6Gateway", vpc_id=vpc_ipv6.id)
foo_ipv6_address_bandwidth = volcengine.vpc.Ipv6AddressBandwidth("fooIpv6AddressBandwidth",
    ipv6_address=private_clb_ipv6.eni_ipv6_address,
    billing_type="PostPaidByBandwidth",
    bandwidth=5,
    opts=pulumi.ResourceOptions(depends_on=[ipv6_gateway]))

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/clb"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/ecs"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/eip"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/vpc"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		fooZones, err := ecs.GetZones(ctx, nil, nil)
		if err != nil {
			return err
		}
		// create vpc
		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
		}
		// create subnet
		fooSubnet, err := vpc.NewSubnet(ctx, "fooSubnet", &vpc.SubnetArgs{
			SubnetName: pulumi.String("acc-test-subnet"),
			CidrBlock:  pulumi.String("172.16.0.0/24"),
			ZoneId:     pulumi.String(fooZones.Zones[0].Id),
			VpcId:      fooVpc.ID(),
		})
		if err != nil {
			return err
		}
		// create ipv4 public clb
		_, err = clb.NewClb(ctx, "publicClb", &clb.ClbArgs{
			Type:             pulumi.String("public"),
			SubnetId:         fooSubnet.ID(),
			LoadBalancerName: pulumi.String("acc-test-clb-public"),
			LoadBalancerSpec: pulumi.String("small_1"),
			Description:      pulumi.String("acc-test-demo"),
			ProjectName:      pulumi.String("default"),
			EipBillingConfig: &clb.ClbEipBillingConfigArgs{
				Isp:            pulumi.String("BGP"),
				EipBillingType: pulumi.String("PostPaidByBandwidth"),
				Bandwidth:      pulumi.Int(1),
			},
			Tags: clb.ClbTagArray{
				&clb.ClbTagArgs{
					Key:   pulumi.String("k1"),
					Value: pulumi.String("v1"),
				},
			},
		})
		if err != nil {
			return err
		}
		// create ipv4 private clb
		privateClb, err := clb.NewClb(ctx, "privateClb", &clb.ClbArgs{
			Type:             pulumi.String("private"),
			SubnetId:         fooSubnet.ID(),
			LoadBalancerName: pulumi.String("acc-test-clb-private"),
			LoadBalancerSpec: pulumi.String("small_1"),
			Description:      pulumi.String("acc-test-demo"),
			ProjectName:      pulumi.String("default"),
		})
		if err != nil {
			return err
		}
		// create eip
		eip, err := eip.NewAddress(ctx, "eip", &eip.AddressArgs{
			BillingType: pulumi.String("PostPaidByBandwidth"),
			Bandwidth:   pulumi.Int(1),
			Isp:         pulumi.String("BGP"),
			Description: pulumi.String("tf-test"),
			ProjectName: pulumi.String("default"),
		})
		if err != nil {
			return err
		}
		// associate eip to clb
		_, err = eip.NewAssociate(ctx, "associate", &eip.AssociateArgs{
			AllocationId: eip.ID(),
			InstanceId:   privateClb.ID(),
			InstanceType: pulumi.String("ClbInstance"),
		})
		if err != nil {
			return err
		}
		// create ipv6 vpc
		vpcIpv6, err := vpc.NewVpc(ctx, "vpcIpv6", &vpc.VpcArgs{
			VpcName:    pulumi.String("acc-test-vpc-ipv6"),
			CidrBlock:  pulumi.String("172.16.0.0/16"),
			EnableIpv6: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		// create ipv6 subnet
		subnetIpv6, err := vpc.NewSubnet(ctx, "subnetIpv6", &vpc.SubnetArgs{
			SubnetName:    pulumi.String("acc-test-subnet-ipv6"),
			CidrBlock:     pulumi.String("172.16.0.0/24"),
			ZoneId:        pulumi.String(fooZones.Zones[1].Id),
			VpcId:         vpcIpv6.ID(),
			Ipv6CidrBlock: pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		// create ipv6 private clb
		privateClbIpv6, err := clb.NewClb(ctx, "privateClbIpv6", &clb.ClbArgs{
			Type:             pulumi.String("private"),
			SubnetId:         subnetIpv6.ID(),
			LoadBalancerName: pulumi.String("acc-test-clb-ipv6"),
			LoadBalancerSpec: pulumi.String("small_1"),
			Description:      pulumi.String("acc-test-demo"),
			ProjectName:      pulumi.String("default"),
			AddressIpVersion: pulumi.String("DualStack"),
		})
		if err != nil {
			return err
		}
		// create ipv6 gateway
		ipv6Gateway, err := vpc.NewIpv6Gateway(ctx, "ipv6Gateway", &vpc.Ipv6GatewayArgs{
			VpcId: vpcIpv6.ID(),
		})
		if err != nil {
			return err
		}
		_, err = vpc.NewIpv6AddressBandwidth(ctx, "fooIpv6AddressBandwidth", &vpc.Ipv6AddressBandwidthArgs{
			Ipv6Address: privateClbIpv6.EniIpv6Address,
			BillingType: pulumi.String("PostPaidByBandwidth"),
			Bandwidth:   pulumi.Int(5),
		}, pulumi.DependsOn([]pulumi.Resource{
			ipv6Gateway,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var fooZones = Volcengine.Ecs.GetZones.Invoke();

    // create vpc
    var fooVpc = new Volcengine.Vpc.Vpc("fooVpc", new()
    {
        VpcName = "acc-test-vpc",
        CidrBlock = "172.16.0.0/16",
    });

    // create subnet
    var fooSubnet = new Volcengine.Vpc.Subnet("fooSubnet", new()
    {
        SubnetName = "acc-test-subnet",
        CidrBlock = "172.16.0.0/24",
        ZoneId = fooZones.Apply(getZonesResult => getZonesResult.Zones[0]?.Id),
        VpcId = fooVpc.Id,
    });

    // create ipv4 public clb
    var publicClb = new Volcengine.Clb.Clb("publicClb", new()
    {
        Type = "public",
        SubnetId = fooSubnet.Id,
        LoadBalancerName = "acc-test-clb-public",
        LoadBalancerSpec = "small_1",
        Description = "acc-test-demo",
        ProjectName = "default",
        EipBillingConfig = new Volcengine.Clb.Inputs.ClbEipBillingConfigArgs
        {
            Isp = "BGP",
            EipBillingType = "PostPaidByBandwidth",
            Bandwidth = 1,
        },
        Tags = new[]
        {
            new Volcengine.Clb.Inputs.ClbTagArgs
            {
                Key = "k1",
                Value = "v1",
            },
        },
    });

    // create ipv4 private clb
    var privateClb = new Volcengine.Clb.Clb("privateClb", new()
    {
        Type = "private",
        SubnetId = fooSubnet.Id,
        LoadBalancerName = "acc-test-clb-private",
        LoadBalancerSpec = "small_1",
        Description = "acc-test-demo",
        ProjectName = "default",
    });

    // create eip
    var eip = new Volcengine.Eip.Address("eip", new()
    {
        BillingType = "PostPaidByBandwidth",
        Bandwidth = 1,
        Isp = "BGP",
        Description = "tf-test",
        ProjectName = "default",
    });

    // associate eip to clb
    var associate = new Volcengine.Eip.Associate("associate", new()
    {
        AllocationId = eip.Id,
        InstanceId = privateClb.Id,
        InstanceType = "ClbInstance",
    });

    // create ipv6 vpc
    var vpcIpv6 = new Volcengine.Vpc.Vpc("vpcIpv6", new()
    {
        VpcName = "acc-test-vpc-ipv6",
        CidrBlock = "172.16.0.0/16",
        EnableIpv6 = true,
    });

    // create ipv6 subnet
    var subnetIpv6 = new Volcengine.Vpc.Subnet("subnetIpv6", new()
    {
        SubnetName = "acc-test-subnet-ipv6",
        CidrBlock = "172.16.0.0/24",
        ZoneId = fooZones.Apply(getZonesResult => getZonesResult.Zones[1]?.Id),
        VpcId = vpcIpv6.Id,
        Ipv6CidrBlock = 1,
    });

    // create ipv6 private clb
    var privateClbIpv6 = new Volcengine.Clb.Clb("privateClbIpv6", new()
    {
        Type = "private",
        SubnetId = subnetIpv6.Id,
        LoadBalancerName = "acc-test-clb-ipv6",
        LoadBalancerSpec = "small_1",
        Description = "acc-test-demo",
        ProjectName = "default",
        AddressIpVersion = "DualStack",
    });

    // create ipv6 gateway
    var ipv6Gateway = new Volcengine.Vpc.Ipv6Gateway("ipv6Gateway", new()
    {
        VpcId = vpcIpv6.Id,
    });

    var fooIpv6AddressBandwidth = new Volcengine.Vpc.Ipv6AddressBandwidth("fooIpv6AddressBandwidth", new()
    {
        Ipv6Address = privateClbIpv6.EniIpv6Address,
        BillingType = "PostPaidByBandwidth",
        Bandwidth = 5,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            ipv6Gateway,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.volcengine.ecs.EcsFunctions;
import com.pulumi.volcengine.ecs.inputs.GetZonesArgs;
import com.pulumi.volcengine.vpc.Vpc;
import com.pulumi.volcengine.vpc.VpcArgs;
import com.pulumi.volcengine.vpc.Subnet;
import com.pulumi.volcengine.vpc.SubnetArgs;
import com.pulumi.volcengine.clb.Clb;
import com.pulumi.volcengine.clb.ClbArgs;
import com.pulumi.volcengine.clb.inputs.ClbEipBillingConfigArgs;
import com.pulumi.volcengine.clb.inputs.ClbTagArgs;
import com.pulumi.volcengine.eip.Address;
import com.pulumi.volcengine.eip.AddressArgs;
import com.pulumi.volcengine.eip.Associate;
import com.pulumi.volcengine.eip.AssociateArgs;
import com.pulumi.volcengine.vpc.Ipv6Gateway;
import com.pulumi.volcengine.vpc.Ipv6GatewayArgs;
import com.pulumi.volcengine.vpc.Ipv6AddressBandwidth;
import com.pulumi.volcengine.vpc.Ipv6AddressBandwidthArgs;
import com.pulumi.resources.CustomResourceOptions;
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 fooZones = EcsFunctions.getZones();

        // create vpc
        var fooVpc = new Vpc("fooVpc", VpcArgs.builder()        
            .vpcName("acc-test-vpc")
            .cidrBlock("172.16.0.0/16")
            .build());

        // create subnet
        var fooSubnet = new Subnet("fooSubnet", SubnetArgs.builder()        
            .subnetName("acc-test-subnet")
            .cidrBlock("172.16.0.0/24")
            .zoneId(fooZones.applyValue(getZonesResult -> getZonesResult.zones()[0].id()))
            .vpcId(fooVpc.id())
            .build());

        // create ipv4 public clb
        var publicClb = new Clb("publicClb", ClbArgs.builder()        
            .type("public")
            .subnetId(fooSubnet.id())
            .loadBalancerName("acc-test-clb-public")
            .loadBalancerSpec("small_1")
            .description("acc-test-demo")
            .projectName("default")
            .eipBillingConfig(ClbEipBillingConfigArgs.builder()
                .isp("BGP")
                .eipBillingType("PostPaidByBandwidth")
                .bandwidth(1)
                .build())
            .tags(ClbTagArgs.builder()
                .key("k1")
                .value("v1")
                .build())
            .build());

        // create ipv4 private clb
        var privateClb = new Clb("privateClb", ClbArgs.builder()        
            .type("private")
            .subnetId(fooSubnet.id())
            .loadBalancerName("acc-test-clb-private")
            .loadBalancerSpec("small_1")
            .description("acc-test-demo")
            .projectName("default")
            .build());

        // create eip
        var eip = new Address("eip", AddressArgs.builder()        
            .billingType("PostPaidByBandwidth")
            .bandwidth(1)
            .isp("BGP")
            .description("tf-test")
            .projectName("default")
            .build());

        // associate eip to clb
        var associate = new Associate("associate", AssociateArgs.builder()        
            .allocationId(eip.id())
            .instanceId(privateClb.id())
            .instanceType("ClbInstance")
            .build());

        // create ipv6 vpc
        var vpcIpv6 = new Vpc("vpcIpv6", VpcArgs.builder()        
            .vpcName("acc-test-vpc-ipv6")
            .cidrBlock("172.16.0.0/16")
            .enableIpv6(true)
            .build());

        // create ipv6 subnet
        var subnetIpv6 = new Subnet("subnetIpv6", SubnetArgs.builder()        
            .subnetName("acc-test-subnet-ipv6")
            .cidrBlock("172.16.0.0/24")
            .zoneId(fooZones.applyValue(getZonesResult -> getZonesResult.zones()[1].id()))
            .vpcId(vpcIpv6.id())
            .ipv6CidrBlock(1)
            .build());

        // create ipv6 private clb
        var privateClbIpv6 = new Clb("privateClbIpv6", ClbArgs.builder()        
            .type("private")
            .subnetId(subnetIpv6.id())
            .loadBalancerName("acc-test-clb-ipv6")
            .loadBalancerSpec("small_1")
            .description("acc-test-demo")
            .projectName("default")
            .addressIpVersion("DualStack")
            .build());

        // create ipv6 gateway
        var ipv6Gateway = new Ipv6Gateway("ipv6Gateway", Ipv6GatewayArgs.builder()        
            .vpcId(vpcIpv6.id())
            .build());

        var fooIpv6AddressBandwidth = new Ipv6AddressBandwidth("fooIpv6AddressBandwidth", Ipv6AddressBandwidthArgs.builder()        
            .ipv6Address(privateClbIpv6.eniIpv6Address())
            .billingType("PostPaidByBandwidth")
            .bandwidth(5)
            .build(), CustomResourceOptions.builder()
                .dependsOn(ipv6Gateway)
                .build());

    }
}

resources:
  # create vpc
  fooVpc:
    type: volcengine:vpc:Vpc
    properties:
      vpcName: acc-test-vpc
      cidrBlock: 172.16.0.0/16
  # create subnet
  fooSubnet:
    type: volcengine:vpc:Subnet
    properties:
      subnetName: acc-test-subnet
      cidrBlock: 172.16.0.0/24
      zoneId: ${fooZones.zones[0].id}
      vpcId: ${fooVpc.id}
  # create ipv4 public clb
  publicClb:
    type: volcengine:clb:Clb
    properties:
      type: public
      subnetId: ${fooSubnet.id}
      loadBalancerName: acc-test-clb-public
      loadBalancerSpec: small_1
      description: acc-test-demo
      projectName: default
      eipBillingConfig:
        isp: BGP
        eipBillingType: PostPaidByBandwidth
        bandwidth: 1
      tags:
        - key: k1
          value: v1
  # create ipv4 private clb
  privateClb:
    type: volcengine:clb:Clb
    properties:
      type: private
      subnetId: ${fooSubnet.id}
      loadBalancerName: acc-test-clb-private
      loadBalancerSpec: small_1
      description: acc-test-demo
      projectName: default
  # create eip
  eip:
    type: volcengine:eip:Address
    properties:
      billingType: PostPaidByBandwidth
      bandwidth: 1
      isp: BGP
      description: tf-test
      projectName: default
  # associate eip to clb
  associate:
    type: volcengine:eip:Associate
    properties:
      allocationId: ${eip.id}
      instanceId: ${privateClb.id}
      instanceType: ClbInstance
  # create ipv6 vpc
  vpcIpv6:
    type: volcengine:vpc:Vpc
    properties:
      vpcName: acc-test-vpc-ipv6
      cidrBlock: 172.16.0.0/16
      enableIpv6: true
  # create ipv6 subnet
  subnetIpv6:
    type: volcengine:vpc:Subnet
    properties:
      subnetName: acc-test-subnet-ipv6
      cidrBlock: 172.16.0.0/24
      zoneId: ${fooZones.zones[1].id}
      vpcId: ${vpcIpv6.id}
      ipv6CidrBlock: 1
  # create ipv6 private clb
  privateClbIpv6:
    type: volcengine:clb:Clb
    properties:
      type: private
      subnetId: ${subnetIpv6.id}
      loadBalancerName: acc-test-clb-ipv6
      loadBalancerSpec: small_1
      description: acc-test-demo
      projectName: default
      addressIpVersion: DualStack
  # create ipv6 gateway
  ipv6Gateway:
    type: volcengine:vpc:Ipv6Gateway
    properties:
      vpcId: ${vpcIpv6.id}
  fooIpv6AddressBandwidth:
    type: volcengine:vpc:Ipv6AddressBandwidth
    properties:
      ipv6Address: ${privateClbIpv6.eniIpv6Address}
      billingType: PostPaidByBandwidth
      bandwidth: 5
    options:
      dependson:
        - ${ipv6Gateway}
variables:
  fooZones:
    fn::invoke:
      Function: volcengine:ecs:getZones
      Arguments: {}

var clbResource = new Volcengine.Clb.Clb("clbResource", new()
{
    SubnetId = "string",
    Type = "string",
    MasterZoneId = "string",
    Period = 0,
    EniIpv6Address = "string",
    LoadBalancerBillingType = "string",
    LoadBalancerName = "string",
    LoadBalancerSpec = "string",
    AddressIpVersion = "string",
    ModificationProtectionReason = "string",
    ModificationProtectionStatus = "string",
    EniAddress = "string",
    ProjectName = "string",
    RegionId = "string",
    SlaveZoneId = "string",
    EipBillingConfig = new Volcengine.Clb.Inputs.ClbEipBillingConfigArgs
    {
        EipBillingType = "string",
        Isp = "string",
        Bandwidth = 0,
    },
    Tags = new[]
    {
        new Volcengine.Clb.Inputs.ClbTagArgs
        {
            Key = "string",
            Value = "string",
        },
    },
    Description = "string",
    VpcId = "string",
});

example, err := clb.NewClb(ctx, "clbResource", &clb.ClbArgs{
	SubnetId:                     pulumi.String("string"),
	Type:                         pulumi.String("string"),
	MasterZoneId:                 pulumi.String("string"),
	Period:                       pulumi.Int(0),
	EniIpv6Address:               pulumi.String("string"),
	LoadBalancerBillingType:      pulumi.String("string"),
	LoadBalancerName:             pulumi.String("string"),
	LoadBalancerSpec:             pulumi.String("string"),
	AddressIpVersion:             pulumi.String("string"),
	ModificationProtectionReason: pulumi.String("string"),
	ModificationProtectionStatus: pulumi.String("string"),
	EniAddress:                   pulumi.String("string"),
	ProjectName:                  pulumi.String("string"),
	RegionId:                     pulumi.String("string"),
	SlaveZoneId:                  pulumi.String("string"),
	EipBillingConfig: &clb.ClbEipBillingConfigArgs{
		EipBillingType: pulumi.String("string"),
		Isp:            pulumi.String("string"),
		Bandwidth:      pulumi.Int(0),
	},
	Tags: clb.ClbTagArray{
		&clb.ClbTagArgs{
			Key:   pulumi.String("string"),
			Value: pulumi.String("string"),
		},
	},
	Description: pulumi.String("string"),
	VpcId:       pulumi.String("string"),
})

var clbResource = new Clb("clbResource", ClbArgs.builder()
    .subnetId("string")
    .type("string")
    .masterZoneId("string")
    .period(0)
    .eniIpv6Address("string")
    .loadBalancerBillingType("string")
    .loadBalancerName("string")
    .loadBalancerSpec("string")
    .addressIpVersion("string")
    .modificationProtectionReason("string")
    .modificationProtectionStatus("string")
    .eniAddress("string")
    .projectName("string")
    .regionId("string")
    .slaveZoneId("string")
    .eipBillingConfig(ClbEipBillingConfigArgs.builder()
        .eipBillingType("string")
        .isp("string")
        .bandwidth(0)
        .build())
    .tags(ClbTagArgs.builder()
        .key("string")
        .value("string")
        .build())
    .description("string")
    .vpcId("string")
    .build());

clb_resource = volcengine.clb.Clb("clbResource",
    subnet_id="string",
    type="string",
    master_zone_id="string",
    period=0,
    eni_ipv6_address="string",
    load_balancer_billing_type="string",
    load_balancer_name="string",
    load_balancer_spec="string",
    address_ip_version="string",
    modification_protection_reason="string",
    modification_protection_status="string",
    eni_address="string",
    project_name="string",
    region_id="string",
    slave_zone_id="string",
    eip_billing_config={
        "eip_billing_type": "string",
        "isp": "string",
        "bandwidth": 0,
    },
    tags=[{
        "key": "string",
        "value": "string",
    }],
    description="string",
    vpc_id="string")

const clbResource = new volcengine.clb.Clb("clbResource", {
    subnetId: "string",
    type: "string",
    masterZoneId: "string",
    period: 0,
    eniIpv6Address: "string",
    loadBalancerBillingType: "string",
    loadBalancerName: "string",
    loadBalancerSpec: "string",
    addressIpVersion: "string",
    modificationProtectionReason: "string",
    modificationProtectionStatus: "string",
    eniAddress: "string",
    projectName: "string",
    regionId: "string",
    slaveZoneId: "string",
    eipBillingConfig: {
        eipBillingType: "string",
        isp: "string",
        bandwidth: 0,
    },
    tags: [{
        key: "string",
        value: "string",
    }],
    description: "string",
    vpcId: "string",
});

type: volcengine:clb:Clb
properties:
    addressIpVersion: string
    description: string
    eipBillingConfig:
        bandwidth: 0
        eipBillingType: string
        isp: string
    eniAddress: string
    eniIpv6Address: string
    loadBalancerBillingType: string
    loadBalancerName: string
    loadBalancerSpec: string
    masterZoneId: string
    modificationProtectionReason: string
    modificationProtectionStatus: string
    period: 0
    projectName: string
    regionId: string
    slaveZoneId: string
    subnetId: string
    tags:
        - key: string
          value: string
    type: string
    vpcId: string