volcengine.alb.Alb

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

return await Deployment.RunAsync(() => 
{
    var foo = Volcengine.Alb.Zones.Invoke();

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

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

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

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

    var alb_private = new Volcengine.Alb.Alb("alb-private", new()
    {
        AddressIpVersion = "IPv4",
        Type = "private",
        LoadBalancerName = "acc-test-alb-private",
        Description = "acc-test",
        SubnetIds = new[]
        {
            subnetIpv61.Id,
            subnetIpv62.Id,
        },
        ProjectName = "default",
        DeleteProtection = "off",
        Tags = new[]
        {
            new Volcengine.Alb.Inputs.AlbTagArgs
            {
                Key = "k1",
                Value = "v1",
            },
        },
    });

    var alb_public = new Volcengine.Alb.Alb("alb-public", new()
    {
        AddressIpVersion = "DualStack",
        Type = "public",
        LoadBalancerName = "acc-test-alb-public",
        Description = "acc-test",
        SubnetIds = new[]
        {
            subnetIpv61.Id,
            subnetIpv62.Id,
        },
        ProjectName = "default",
        DeleteProtection = "off",
        EipBillingConfig = new Volcengine.Alb.Inputs.AlbEipBillingConfigArgs
        {
            Isp = "BGP",
            EipBillingType = "PostPaidByBandwidth",
            Bandwidth = 1,
        },
        Ipv6EipBillingConfig = new Volcengine.Alb.Inputs.AlbIpv6EipBillingConfigArgs
        {
            Isp = "BGP",
            BillingType = "PostPaidByBandwidth",
            Bandwidth = 1,
        },
        Tags = new[]
        {
            new Volcengine.Alb.Inputs.AlbTagArgs
            {
                Key = "k1",
                Value = "v1",
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn = new[]
        {
            ipv6Gateway,
        },
    });

});

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 {
		foo, err := alb.Zones(ctx, nil, nil)
		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
		}
		subnetIpv61, err := vpc.NewSubnet(ctx, "subnetIpv61", &vpc.SubnetArgs{
			SubnetName:    pulumi.String("acc-test-subnet-ipv6-1"),
			CidrBlock:     pulumi.String("172.16.1.0/24"),
			ZoneId:        *pulumi.String(foo.Zones[0].Id),
			VpcId:         vpcIpv6.ID(),
			Ipv6CidrBlock: pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		subnetIpv62, err := vpc.NewSubnet(ctx, "subnetIpv62", &vpc.SubnetArgs{
			SubnetName:    pulumi.String("acc-test-subnet-ipv6-2"),
			CidrBlock:     pulumi.String("172.16.2.0/24"),
			ZoneId:        *pulumi.String(foo.Zones[1].Id),
			VpcId:         vpcIpv6.ID(),
			Ipv6CidrBlock: pulumi.Int(2),
		})
		if err != nil {
			return err
		}
		ipv6Gateway, err := vpc.NewIpv6Gateway(ctx, "ipv6Gateway", &vpc.Ipv6GatewayArgs{
			VpcId: vpcIpv6.ID(),
		})
		if err != nil {
			return err
		}
		_, err = alb.NewAlb(ctx, "alb-private", &alb.AlbArgs{
			AddressIpVersion: pulumi.String("IPv4"),
			Type:             pulumi.String("private"),
			LoadBalancerName: pulumi.String("acc-test-alb-private"),
			Description:      pulumi.String("acc-test"),
			SubnetIds: pulumi.StringArray{
				subnetIpv61.ID(),
				subnetIpv62.ID(),
			},
			ProjectName:      pulumi.String("default"),
			DeleteProtection: pulumi.String("off"),
			Tags: alb.AlbTagArray{
				&alb.AlbTagArgs{
					Key:   pulumi.String("k1"),
					Value: pulumi.String("v1"),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = alb.NewAlb(ctx, "alb-public", &alb.AlbArgs{
			AddressIpVersion: pulumi.String("DualStack"),
			Type:             pulumi.String("public"),
			LoadBalancerName: pulumi.String("acc-test-alb-public"),
			Description:      pulumi.String("acc-test"),
			SubnetIds: pulumi.StringArray{
				subnetIpv61.ID(),
				subnetIpv62.ID(),
			},
			ProjectName:      pulumi.String("default"),
			DeleteProtection: pulumi.String("off"),
			EipBillingConfig: &alb.AlbEipBillingConfigArgs{
				Isp:            pulumi.String("BGP"),
				EipBillingType: pulumi.String("PostPaidByBandwidth"),
				Bandwidth:      pulumi.Int(1),
			},
			Ipv6EipBillingConfig: &alb.AlbIpv6EipBillingConfigArgs{
				Isp:         pulumi.String("BGP"),
				BillingType: pulumi.String("PostPaidByBandwidth"),
				Bandwidth:   pulumi.Int(1),
			},
			Tags: alb.AlbTagArray{
				&alb.AlbTagArgs{
					Key:   pulumi.String("k1"),
					Value: pulumi.String("v1"),
				},
			},
		}, 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.alb.AlbFunctions;
import com.pulumi.volcengine.alb.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.vpc.Ipv6Gateway;
import com.pulumi.volcengine.vpc.Ipv6GatewayArgs;
import com.pulumi.volcengine.alb.Alb;
import com.pulumi.volcengine.alb.AlbArgs;
import com.pulumi.volcengine.alb.inputs.AlbTagArgs;
import com.pulumi.volcengine.alb.inputs.AlbEipBillingConfigArgs;
import com.pulumi.volcengine.alb.inputs.AlbIpv6EipBillingConfigArgs;
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 foo = AlbFunctions.Zones();

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

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

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

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

        var alb_private = new Alb("alb-private", AlbArgs.builder()        
            .addressIpVersion("IPv4")
            .type("private")
            .loadBalancerName("acc-test-alb-private")
            .description("acc-test")
            .subnetIds(            
                subnetIpv61.id(),
                subnetIpv62.id())
            .projectName("default")
            .deleteProtection("off")
            .tags(AlbTagArgs.builder()
                .key("k1")
                .value("v1")
                .build())
            .build());

        var alb_public = new Alb("alb-public", AlbArgs.builder()        
            .addressIpVersion("DualStack")
            .type("public")
            .loadBalancerName("acc-test-alb-public")
            .description("acc-test")
            .subnetIds(            
                subnetIpv61.id(),
                subnetIpv62.id())
            .projectName("default")
            .deleteProtection("off")
            .eipBillingConfig(AlbEipBillingConfigArgs.builder()
                .isp("BGP")
                .eipBillingType("PostPaidByBandwidth")
                .bandwidth(1)
                .build())
            .ipv6EipBillingConfig(AlbIpv6EipBillingConfigArgs.builder()
                .isp("BGP")
                .billingType("PostPaidByBandwidth")
                .bandwidth(1)
                .build())
            .tags(AlbTagArgs.builder()
                .key("k1")
                .value("v1")
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(ipv6Gateway)
                .build());

    }
}

import pulumi
import pulumi_volcengine as volcengine

foo = volcengine.alb.zones()
vpc_ipv6 = volcengine.vpc.Vpc("vpcIpv6",
    vpc_name="acc-test-vpc-ipv6",
    cidr_block="172.16.0.0/16",
    enable_ipv6=True)
subnet_ipv61 = volcengine.vpc.Subnet("subnetIpv61",
    subnet_name="acc-test-subnet-ipv6-1",
    cidr_block="172.16.1.0/24",
    zone_id=foo.zones[0].id,
    vpc_id=vpc_ipv6.id,
    ipv6_cidr_block=1)
subnet_ipv62 = volcengine.vpc.Subnet("subnetIpv62",
    subnet_name="acc-test-subnet-ipv6-2",
    cidr_block="172.16.2.0/24",
    zone_id=foo.zones[1].id,
    vpc_id=vpc_ipv6.id,
    ipv6_cidr_block=2)
ipv6_gateway = volcengine.vpc.Ipv6Gateway("ipv6Gateway", vpc_id=vpc_ipv6.id)
alb_private = volcengine.alb.Alb("alb-private",
    address_ip_version="IPv4",
    type="private",
    load_balancer_name="acc-test-alb-private",
    description="acc-test",
    subnet_ids=[
        subnet_ipv61.id,
        subnet_ipv62.id,
    ],
    project_name="default",
    delete_protection="off",
    tags=[volcengine.alb.AlbTagArgs(
        key="k1",
        value="v1",
    )])
alb_public = volcengine.alb.Alb("alb-public",
    address_ip_version="DualStack",
    type="public",
    load_balancer_name="acc-test-alb-public",
    description="acc-test",
    subnet_ids=[
        subnet_ipv61.id,
        subnet_ipv62.id,
    ],
    project_name="default",
    delete_protection="off",
    eip_billing_config=volcengine.alb.AlbEipBillingConfigArgs(
        isp="BGP",
        eip_billing_type="PostPaidByBandwidth",
        bandwidth=1,
    ),
    ipv6_eip_billing_config=volcengine.alb.AlbIpv6EipBillingConfigArgs(
        isp="BGP",
        billing_type="PostPaidByBandwidth",
        bandwidth=1,
    ),
    tags=[volcengine.alb.AlbTagArgs(
        key="k1",
        value="v1",
    )],
    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 foo = volcengine.alb.Zones({});
const vpcIpv6 = new volcengine.vpc.Vpc("vpcIpv6", {
    vpcName: "acc-test-vpc-ipv6",
    cidrBlock: "172.16.0.0/16",
    enableIpv6: true,
});
const subnetIpv61 = new volcengine.vpc.Subnet("subnetIpv61", {
    subnetName: "acc-test-subnet-ipv6-1",
    cidrBlock: "172.16.1.0/24",
    zoneId: foo.then(foo => foo.zones?.[0]?.id),
    vpcId: vpcIpv6.id,
    ipv6CidrBlock: 1,
});
const subnetIpv62 = new volcengine.vpc.Subnet("subnetIpv62", {
    subnetName: "acc-test-subnet-ipv6-2",
    cidrBlock: "172.16.2.0/24",
    zoneId: foo.then(foo => foo.zones?.[1]?.id),
    vpcId: vpcIpv6.id,
    ipv6CidrBlock: 2,
});
const ipv6Gateway = new volcengine.vpc.Ipv6Gateway("ipv6Gateway", {vpcId: vpcIpv6.id});
const alb_private = new volcengine.alb.Alb("alb-private", {
    addressIpVersion: "IPv4",
    type: "private",
    loadBalancerName: "acc-test-alb-private",
    description: "acc-test",
    subnetIds: [
        subnetIpv61.id,
        subnetIpv62.id,
    ],
    projectName: "default",
    deleteProtection: "off",
    tags: [{
        key: "k1",
        value: "v1",
    }],
});
const alb_public = new volcengine.alb.Alb("alb-public", {
    addressIpVersion: "DualStack",
    type: "public",
    loadBalancerName: "acc-test-alb-public",
    description: "acc-test",
    subnetIds: [
        subnetIpv61.id,
        subnetIpv62.id,
    ],
    projectName: "default",
    deleteProtection: "off",
    eipBillingConfig: {
        isp: "BGP",
        eipBillingType: "PostPaidByBandwidth",
        bandwidth: 1,
    },
    ipv6EipBillingConfig: {
        isp: "BGP",
        billingType: "PostPaidByBandwidth",
        bandwidth: 1,
    },
    tags: [{
        key: "k1",
        value: "v1",
    }],
}, {
    dependsOn: [ipv6Gateway],
});

resources:
  vpcIpv6:
    type: volcengine:vpc:Vpc
    properties:
      vpcName: acc-test-vpc-ipv6
      cidrBlock: 172.16.0.0/16
      enableIpv6: true
  subnetIpv61:
    type: volcengine:vpc:Subnet
    properties:
      subnetName: acc-test-subnet-ipv6-1
      cidrBlock: 172.16.1.0/24
      zoneId: ${foo.zones[0].id}
      vpcId: ${vpcIpv6.id}
      ipv6CidrBlock: 1
  subnetIpv62:
    type: volcengine:vpc:Subnet
    properties:
      subnetName: acc-test-subnet-ipv6-2
      cidrBlock: 172.16.2.0/24
      zoneId: ${foo.zones[1].id}
      vpcId: ${vpcIpv6.id}
      ipv6CidrBlock: 2
  ipv6Gateway:
    type: volcengine:vpc:Ipv6Gateway
    properties:
      vpcId: ${vpcIpv6.id}
  alb-private:
    type: volcengine:alb:Alb
    properties:
      addressIpVersion: IPv4
      type: private
      loadBalancerName: acc-test-alb-private
      description: acc-test
      subnetIds:
        - ${subnetIpv61.id}
        - ${subnetIpv62.id}
      projectName: default
      deleteProtection: off
      tags:
        - key: k1
          value: v1
  alb-public:
    type: volcengine:alb:Alb
    properties:
      addressIpVersion: DualStack
      type: public
      loadBalancerName: acc-test-alb-public
      description: acc-test
      subnetIds:
        - ${subnetIpv61.id}
        - ${subnetIpv62.id}
      projectName: default
      deleteProtection: off
      eipBillingConfig:
        isp: BGP
        eipBillingType: PostPaidByBandwidth
        bandwidth: 1
      ipv6EipBillingConfig:
        isp: BGP
        billingType: PostPaidByBandwidth
        bandwidth: 1
      tags:
        - key: k1
          value: v1
    options:
      dependson:
        - ${ipv6Gateway}
variables:
  foo:
    fn::invoke:
      Function: volcengine:alb:Zones
      Arguments: {}