volcengine.clb.Clb

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

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

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

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

    // 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",
            },
        },
    });

    // 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",
    });

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

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

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

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

    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",
    });

    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 = new[]
        {
            ipv6Gateway,
        },
    });

});

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.Zones(ctx, nil, nil)
		if err != nil {
			return err
		}
		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
		}
		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
		}
		_, 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
		}
		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
		}
		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
		}
		_, err = eip.NewAssociate(ctx, "associate", &eip.AssociateArgs{
			AllocationId: eip.ID(),
			InstanceId:   privateClb.ID(),
			InstanceType: pulumi.String("ClbInstance"),
		})
		if err != nil {
			return err
		}
		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
		}
		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
		}
		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
		}
		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
	})
}

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.ZonesArgs;
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.Zones();

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

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

        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());

        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());

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

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

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

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

        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());

        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());

    }
}

import pulumi
import pulumi_volcengine as volcengine

foo_zones = volcengine.ecs.zones()
foo_vpc = volcengine.vpc.Vpc("fooVpc",
    vpc_name="acc-test-vpc",
    cidr_block="172.16.0.0/16")
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)
# 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",
    )])
# 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")
eip = volcengine.eip.Address("eip",
    billing_type="PostPaidByBandwidth",
    bandwidth=1,
    isp="BGP",
    description="tf-test",
    project_name="default")
associate = volcengine.eip.Associate("associate",
    allocation_id=eip.id,
    instance_id=private_clb.id,
    instance_type="ClbInstance")
# ipv6 private clb
vpc_ipv6 = volcengine.vpc.Vpc("vpcIpv6",
    vpc_name="acc-test-vpc-ipv6",
    cidr_block="172.16.0.0/16",
    enable_ipv6=True)
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)
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")
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]))

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

const fooZones = volcengine.ecs.Zones({});
const fooVpc = new volcengine.vpc.Vpc("fooVpc", {
    vpcName: "acc-test-vpc",
    cidrBlock: "172.16.0.0/16",
});
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,
});
// 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",
    }],
});
// 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",
});
const eip = new volcengine.eip.Address("eip", {
    billingType: "PostPaidByBandwidth",
    bandwidth: 1,
    isp: "BGP",
    description: "tf-test",
    projectName: "default",
});
const associate = new volcengine.eip.Associate("associate", {
    allocationId: eip.id,
    instanceId: privateClb.id,
    instanceType: "ClbInstance",
});
// ipv6 private clb
const vpcIpv6 = new volcengine.vpc.Vpc("vpcIpv6", {
    vpcName: "acc-test-vpc-ipv6",
    cidrBlock: "172.16.0.0/16",
    enableIpv6: true,
});
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,
});
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",
});
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],
});

resources:
  fooVpc:
    type: volcengine:vpc:Vpc
    properties:
      vpcName: acc-test-vpc
      cidrBlock: 172.16.0.0/16
  fooSubnet:
    type: volcengine:vpc:Subnet
    properties:
      subnetName: acc-test-subnet
      cidrBlock: 172.16.0.0/24
      zoneId: ${fooZones.zones[0].id}
      vpcId: ${fooVpc.id}
  # 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
  # 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
  eip:
    type: volcengine:eip:Address
    properties:
      billingType: PostPaidByBandwidth
      bandwidth: 1
      isp: BGP
      description: tf-test
      projectName: default
  associate:
    type: volcengine:eip:Associate
    properties:
      allocationId: ${eip.id}
      instanceId: ${privateClb.id}
      instanceType: ClbInstance
  # ipv6 private clb
  vpcIpv6:
    type: volcengine:vpc:Vpc
    properties:
      vpcName: acc-test-vpc-ipv6
      cidrBlock: 172.16.0.0/16
      enableIpv6: true
  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
  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
  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:Zones
      Arguments: {}