volcengine.privatelink.VpcEndpointZones

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,
});
const fooSecurityGroup = new volcengine.vpc.SecurityGroup("fooSecurityGroup", {
    securityGroupName: "acc-test-security-group",
    vpcId: fooVpc.id,
});
const fooClb = new volcengine.clb.Clb("fooClb", {
    type: "public",
    subnetId: fooSubnet.id,
    loadBalancerSpec: "small_1",
    description: "acc-test-demo",
    loadBalancerName: "acc-test-clb",
    loadBalancerBillingType: "PostPaid",
    eipBillingConfig: {
        isp: "BGP",
        eipBillingType: "PostPaidByBandwidth",
        bandwidth: 1,
    },
    tags: [{
        key: "k1",
        value: "v1",
    }],
});
const fooVpcEndpointService = new volcengine.privatelink.VpcEndpointService("fooVpcEndpointService", {
    resources: [{
        resourceId: fooClb.id,
        resourceType: "CLB",
    }],
    description: "acc-test",
    autoAcceptEnabled: true,
});
const fooVpcEndpoint = new volcengine.privatelink.VpcEndpoint("fooVpcEndpoint", {
    securityGroupIds: [fooSecurityGroup.id],
    serviceId: fooVpcEndpointService.id,
    endpointName: "acc-test-ep",
    description: "acc-test",
});
const fooVpcEndpointZone = new volcengine.privatelink.VpcEndpointZone("fooVpcEndpointZone", {
    endpointId: fooVpcEndpoint.id,
    subnetId: fooSubnet.id,
    privateIpAddress: "172.16.0.251",
});
const fooVpcEndpointZones = volcengine.privatelink.VpcEndpointZonesOutput({
    endpointId: fooVpcEndpointZone.endpointId,
});

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)
foo_security_group = volcengine.vpc.SecurityGroup("fooSecurityGroup",
    security_group_name="acc-test-security-group",
    vpc_id=foo_vpc.id)
foo_clb = volcengine.clb.Clb("fooClb",
    type="public",
    subnet_id=foo_subnet.id,
    load_balancer_spec="small_1",
    description="acc-test-demo",
    load_balancer_name="acc-test-clb",
    load_balancer_billing_type="PostPaid",
    eip_billing_config=volcengine.clb.ClbEipBillingConfigArgs(
        isp="BGP",
        eip_billing_type="PostPaidByBandwidth",
        bandwidth=1,
    ),
    tags=[volcengine.clb.ClbTagArgs(
        key="k1",
        value="v1",
    )])
foo_vpc_endpoint_service = volcengine.privatelink.VpcEndpointService("fooVpcEndpointService",
    resources=[volcengine.privatelink.VpcEndpointServiceResourceArgs(
        resource_id=foo_clb.id,
        resource_type="CLB",
    )],
    description="acc-test",
    auto_accept_enabled=True)
foo_vpc_endpoint = volcengine.privatelink.VpcEndpoint("fooVpcEndpoint",
    security_group_ids=[foo_security_group.id],
    service_id=foo_vpc_endpoint_service.id,
    endpoint_name="acc-test-ep",
    description="acc-test")
foo_vpc_endpoint_zone = volcengine.privatelink.VpcEndpointZone("fooVpcEndpointZone",
    endpoint_id=foo_vpc_endpoint.id,
    subnet_id=foo_subnet.id,
    private_ip_address="172.16.0.251")
foo_vpc_endpoint_zones = volcengine.privatelink.vpc_endpoint_zones_output(endpoint_id=foo_vpc_endpoint_zone.endpoint_id)

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/privatelink"
	"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
		}
		fooSecurityGroup, err := vpc.NewSecurityGroup(ctx, "fooSecurityGroup", &vpc.SecurityGroupArgs{
			SecurityGroupName: pulumi.String("acc-test-security-group"),
			VpcId:             fooVpc.ID(),
		})
		if err != nil {
			return err
		}
		fooClb, err := clb.NewClb(ctx, "fooClb", &clb.ClbArgs{
			Type:                    pulumi.String("public"),
			SubnetId:                fooSubnet.ID(),
			LoadBalancerSpec:        pulumi.String("small_1"),
			Description:             pulumi.String("acc-test-demo"),
			LoadBalancerName:        pulumi.String("acc-test-clb"),
			LoadBalancerBillingType: pulumi.String("PostPaid"),
			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
		}
		fooVpcEndpointService, err := privatelink.NewVpcEndpointService(ctx, "fooVpcEndpointService", &privatelink.VpcEndpointServiceArgs{
			Resources: privatelink.VpcEndpointServiceResourceTypeArray{
				&privatelink.VpcEndpointServiceResourceTypeArgs{
					ResourceId:   fooClb.ID(),
					ResourceType: pulumi.String("CLB"),
				},
			},
			Description:       pulumi.String("acc-test"),
			AutoAcceptEnabled: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		fooVpcEndpoint, err := privatelink.NewVpcEndpoint(ctx, "fooVpcEndpoint", &privatelink.VpcEndpointArgs{
			SecurityGroupIds: pulumi.StringArray{
				fooSecurityGroup.ID(),
			},
			ServiceId:    fooVpcEndpointService.ID(),
			EndpointName: pulumi.String("acc-test-ep"),
			Description:  pulumi.String("acc-test"),
		})
		if err != nil {
			return err
		}
		fooVpcEndpointZone, err := privatelink.NewVpcEndpointZone(ctx, "fooVpcEndpointZone", &privatelink.VpcEndpointZoneArgs{
			EndpointId:       fooVpcEndpoint.ID(),
			SubnetId:         fooSubnet.ID(),
			PrivateIpAddress: pulumi.String("172.16.0.251"),
		})
		if err != nil {
			return err
		}
		_ = privatelink.VpcEndpointZonesOutput(ctx, privatelink.VpcEndpointZonesOutputArgs{
			EndpointId: fooVpcEndpointZone.EndpointId,
		}, nil)
		return nil
	})
}

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

    var fooSecurityGroup = new Volcengine.Vpc.SecurityGroup("fooSecurityGroup", new()
    {
        SecurityGroupName = "acc-test-security-group",
        VpcId = fooVpc.Id,
    });

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

    var fooVpcEndpointService = new Volcengine.Privatelink.VpcEndpointService("fooVpcEndpointService", new()
    {
        Resources = new[]
        {
            new Volcengine.Privatelink.Inputs.VpcEndpointServiceResourceArgs
            {
                ResourceId = fooClb.Id,
                ResourceType = "CLB",
            },
        },
        Description = "acc-test",
        AutoAcceptEnabled = true,
    });

    var fooVpcEndpoint = new Volcengine.Privatelink.VpcEndpoint("fooVpcEndpoint", new()
    {
        SecurityGroupIds = new[]
        {
            fooSecurityGroup.Id,
        },
        ServiceId = fooVpcEndpointService.Id,
        EndpointName = "acc-test-ep",
        Description = "acc-test",
    });

    var fooVpcEndpointZone = new Volcengine.Privatelink.VpcEndpointZone("fooVpcEndpointZone", new()
    {
        EndpointId = fooVpcEndpoint.Id,
        SubnetId = fooSubnet.Id,
        PrivateIpAddress = "172.16.0.251",
    });

    var fooVpcEndpointZones = Volcengine.Privatelink.VpcEndpointZones.Invoke(new()
    {
        EndpointId = fooVpcEndpointZone.EndpointId,
    });

});

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.vpc.SecurityGroup;
import com.pulumi.volcengine.vpc.SecurityGroupArgs;
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.privatelink.VpcEndpointService;
import com.pulumi.volcengine.privatelink.VpcEndpointServiceArgs;
import com.pulumi.volcengine.privatelink.inputs.VpcEndpointServiceResourceArgs;
import com.pulumi.volcengine.privatelink.VpcEndpoint;
import com.pulumi.volcengine.privatelink.VpcEndpointArgs;
import com.pulumi.volcengine.privatelink.VpcEndpointZone;
import com.pulumi.volcengine.privatelink.VpcEndpointZoneArgs;
import com.pulumi.volcengine.privatelink.PrivatelinkFunctions;
import com.pulumi.volcengine.privatelink_vpcEndpointZones.inputs.VpcEndpointZonesArgs;
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 fooSecurityGroup = new SecurityGroup("fooSecurityGroup", SecurityGroupArgs.builder()        
            .securityGroupName("acc-test-security-group")
            .vpcId(fooVpc.id())
            .build());

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

        var fooVpcEndpointService = new VpcEndpointService("fooVpcEndpointService", VpcEndpointServiceArgs.builder()        
            .resources(VpcEndpointServiceResourceArgs.builder()
                .resourceId(fooClb.id())
                .resourceType("CLB")
                .build())
            .description("acc-test")
            .autoAcceptEnabled(true)
            .build());

        var fooVpcEndpoint = new VpcEndpoint("fooVpcEndpoint", VpcEndpointArgs.builder()        
            .securityGroupIds(fooSecurityGroup.id())
            .serviceId(fooVpcEndpointService.id())
            .endpointName("acc-test-ep")
            .description("acc-test")
            .build());

        var fooVpcEndpointZone = new VpcEndpointZone("fooVpcEndpointZone", VpcEndpointZoneArgs.builder()        
            .endpointId(fooVpcEndpoint.id())
            .subnetId(fooSubnet.id())
            .privateIpAddress("172.16.0.251")
            .build());

        final var fooVpcEndpointZones = PrivatelinkFunctions.VpcEndpointZones(VpcEndpointZonesArgs.builder()
            .endpointId(fooVpcEndpointZone.endpointId())
            .build());

    }
}

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}
  fooSecurityGroup:
    type: volcengine:vpc:SecurityGroup
    properties:
      securityGroupName: acc-test-security-group
      vpcId: ${fooVpc.id}
  fooClb:
    type: volcengine:clb:Clb
    properties:
      type: public
      subnetId: ${fooSubnet.id}
      loadBalancerSpec: small_1
      description: acc-test-demo
      loadBalancerName: acc-test-clb
      loadBalancerBillingType: PostPaid
      eipBillingConfig:
        isp: BGP
        eipBillingType: PostPaidByBandwidth
        bandwidth: 1
      tags:
        - key: k1
          value: v1
  fooVpcEndpointService:
    type: volcengine:privatelink:VpcEndpointService
    properties:
      resources:
        - resourceId: ${fooClb.id}
          resourceType: CLB
      description: acc-test
      autoAcceptEnabled: true
  fooVpcEndpoint:
    type: volcengine:privatelink:VpcEndpoint
    properties:
      securityGroupIds:
        - ${fooSecurityGroup.id}
      serviceId: ${fooVpcEndpointService.id}
      endpointName: acc-test-ep
      description: acc-test
  fooVpcEndpointZone:
    type: volcengine:privatelink:VpcEndpointZone
    properties:
      endpointId: ${fooVpcEndpoint.id}
      subnetId: ${fooSubnet.id}
      privateIpAddress: 172.16.0.251
variables:
  fooZones:
    fn::invoke:
      Function: volcengine:ecs:Zones
      Arguments: {}
  fooVpcEndpointZones:
    fn::invoke:
      Function: volcengine:privatelink:VpcEndpointZones
      Arguments:
        endpointId: ${fooVpcEndpointZone.endpointId}

function vpcEndpointZones(args: VpcEndpointZonesArgs, opts?: InvokeOptions): Promise<VpcEndpointZonesResult>
function vpcEndpointZonesOutput(args: VpcEndpointZonesOutputArgs, opts?: InvokeOptions): Output<VpcEndpointZonesResult>

def vpc_endpoint_zones(endpoint_id: Optional[str] = None,
                       output_file: Optional[str] = None,
                       opts: Optional[InvokeOptions] = None) -> VpcEndpointZonesResult
def vpc_endpoint_zones_output(endpoint_id: Optional[pulumi.Input[str]] = None,
                       output_file: Optional[pulumi.Input[str]] = None,
                       opts: Optional[InvokeOptions] = None) -> Output[VpcEndpointZonesResult]

func VpcEndpointZones(ctx *Context, args *VpcEndpointZonesArgs, opts ...InvokeOption) (*VpcEndpointZonesResult, error)
func VpcEndpointZonesOutput(ctx *Context, args *VpcEndpointZonesOutputArgs, opts ...InvokeOption) VpcEndpointZonesResultOutput

public static class VpcEndpointZones 
{
    public static Task<VpcEndpointZonesResult> InvokeAsync(VpcEndpointZonesArgs args, InvokeOptions? opts = null)
    public static Output<VpcEndpointZonesResult> Invoke(VpcEndpointZonesInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<VpcEndpointZonesResult> vpcEndpointZones(VpcEndpointZonesArgs args, InvokeOptions options)
public static Output<VpcEndpointZonesResult> vpcEndpointZones(VpcEndpointZonesArgs args, InvokeOptions options)

fn::invoke:
  function: volcengine:privatelink:VpcEndpointZones
  arguments:
    # arguments dictionary