volcengine.privatelink.VpcEndpointConnections

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

const fooZones = volcengine.ecs.getZones({});
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",
});
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 fooVpcEndpointConnection = new volcengine.privatelink.VpcEndpointConnection("fooVpcEndpointConnection", {
    endpointId: fooVpcEndpoint.id,
    serviceId: fooVpcEndpointService.id,
}, {
    dependsOn: [fooVpcEndpointZone],
});
const fooVpcEndpointConnections = volcengine.privatelink.getVpcEndpointConnectionsOutput({
    endpointId: fooVpcEndpointConnection.endpointId,
    serviceId: fooVpcEndpointConnection.serviceId,
});

import pulumi
import pulumi_volcengine as volcengine

foo_zones = volcengine.ecs.get_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")
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_connection = volcengine.privatelink.VpcEndpointConnection("fooVpcEndpointConnection",
    endpoint_id=foo_vpc_endpoint.id,
    service_id=foo_vpc_endpoint_service.id,
    opts=pulumi.ResourceOptions(depends_on=[foo_vpc_endpoint_zone]))
foo_vpc_endpoint_connections = volcengine.privatelink.get_vpc_endpoint_connections_output(endpoint_id=foo_vpc_endpoint_connection.endpoint_id,
    service_id=foo_vpc_endpoint_connection.service_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.GetZones(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"),
		})
		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
		}
		fooVpcEndpointConnection, err := privatelink.NewVpcEndpointConnection(ctx, "fooVpcEndpointConnection", &privatelink.VpcEndpointConnectionArgs{
			EndpointId: fooVpcEndpoint.ID(),
			ServiceId:  fooVpcEndpointService.ID(),
		}, pulumi.DependsOn([]pulumi.Resource{
			fooVpcEndpointZone,
		}))
		if err != nil {
			return err
		}
		_ = privatelink.GetVpcEndpointConnectionsOutput(ctx, privatelink.GetVpcEndpointConnectionsOutputArgs{
			EndpointId: fooVpcEndpointConnection.EndpointId,
			ServiceId:  fooVpcEndpointConnection.ServiceId,
		}, nil)
		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();

    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(getZonesResult => getZonesResult.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",
    });

    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 fooVpcEndpointConnection = new Volcengine.Privatelink.VpcEndpointConnection("fooVpcEndpointConnection", new()
    {
        EndpointId = fooVpcEndpoint.Id,
        ServiceId = fooVpcEndpointService.Id,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            fooVpcEndpointZone,
        },
    });

    var fooVpcEndpointConnections = Volcengine.Privatelink.GetVpcEndpointConnections.Invoke(new()
    {
        EndpointId = fooVpcEndpointConnection.EndpointId,
        ServiceId = fooVpcEndpointConnection.ServiceId,
    });

});

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.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.VpcEndpointConnection;
import com.pulumi.volcengine.privatelink.VpcEndpointConnectionArgs;
import com.pulumi.volcengine.privatelink.PrivatelinkFunctions;
import com.pulumi.volcengine.privatelink.inputs.GetVpcEndpointConnectionsArgs;
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();

        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(getZonesResult -> getZonesResult.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")
            .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());

        var fooVpcEndpointConnection = new VpcEndpointConnection("fooVpcEndpointConnection", VpcEndpointConnectionArgs.builder()        
            .endpointId(fooVpcEndpoint.id())
            .serviceId(fooVpcEndpointService.id())
            .build(), CustomResourceOptions.builder()
                .dependsOn(fooVpcEndpointZone)
                .build());

        final var fooVpcEndpointConnections = PrivatelinkFunctions.getVpcEndpointConnections(GetVpcEndpointConnectionsArgs.builder()
            .endpointId(fooVpcEndpointConnection.endpointId())
            .serviceId(fooVpcEndpointConnection.serviceId())
            .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
  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
  fooVpcEndpointConnection:
    type: volcengine:privatelink:VpcEndpointConnection
    properties:
      endpointId: ${fooVpcEndpoint.id}
      serviceId: ${fooVpcEndpointService.id}
    options:
      dependson:
        - ${fooVpcEndpointZone}
variables:
  fooZones:
    fn::invoke:
      Function: volcengine:ecs:getZones
      Arguments: {}
  fooVpcEndpointConnections:
    fn::invoke:
      Function: volcengine:privatelink:getVpcEndpointConnections
      Arguments:
        endpointId: ${fooVpcEndpointConnection.endpointId}
        serviceId: ${fooVpcEndpointConnection.serviceId}

function vpcEndpointConnections(args: VpcEndpointConnectionsArgs, opts?: InvokeOptions): Promise<VpcEndpointConnectionsResult>
function vpcEndpointConnectionsOutput(args: VpcEndpointConnectionsOutputArgs, opts?: InvokeOptions): Output<VpcEndpointConnectionsResult>

def vpc_endpoint_connections(endpoint_id: Optional[str] = None,
                             endpoint_owner_account_id: Optional[str] = None,
                             output_file: Optional[str] = None,
                             service_id: Optional[str] = None,
                             opts: Optional[InvokeOptions] = None) -> VpcEndpointConnectionsResult
def vpc_endpoint_connections_output(endpoint_id: Optional[pulumi.Input[str]] = None,
                             endpoint_owner_account_id: Optional[pulumi.Input[str]] = None,
                             output_file: Optional[pulumi.Input[str]] = None,
                             service_id: Optional[pulumi.Input[str]] = None,
                             opts: Optional[InvokeOptions] = None) -> Output[VpcEndpointConnectionsResult]

func VpcEndpointConnections(ctx *Context, args *VpcEndpointConnectionsArgs, opts ...InvokeOption) (*VpcEndpointConnectionsResult, error)
func VpcEndpointConnectionsOutput(ctx *Context, args *VpcEndpointConnectionsOutputArgs, opts ...InvokeOption) VpcEndpointConnectionsResultOutput

public static class VpcEndpointConnections 
{
    public static Task<VpcEndpointConnectionsResult> InvokeAsync(VpcEndpointConnectionsArgs args, InvokeOptions? opts = null)
    public static Output<VpcEndpointConnectionsResult> Invoke(VpcEndpointConnectionsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<VpcEndpointConnectionsResult> vpcEndpointConnections(VpcEndpointConnectionsArgs args, InvokeOptions options)
public static Output<VpcEndpointConnectionsResult> vpcEndpointConnections(VpcEndpointConnectionsArgs args, InvokeOptions options)

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