pulumi-azure-kotlin/com.pulumi.azure.privatelink.kotlin/EndpointArgs

EndpointArgs

data class EndpointArgs(val customNetworkInterfaceName: Output<String>? = null, val ipConfigurations: Output<List<EndpointIpConfigurationArgs>>? = null, val location: Output<String>? = null, val name: Output<String>? = null, val privateDnsZoneGroup: Output<EndpointPrivateDnsZoneGroupArgs>? = null, val privateServiceConnection: Output<EndpointPrivateServiceConnectionArgs>? = null, val resourceGroupName: Output<String>? = null, val subnetId: Output<String>? = null, val tags: Output<Map<String, String>>? = null) : ConvertibleToJava<EndpointArgs>

Manages a Private Endpoint. Azure Private Endpoint is a network interface that connects you privately and securely to a service powered by Azure Private Link. Private Endpoint uses a private IP address from your VNet, effectively bringing the service into your VNet. The service could be an Azure service such as Azure Storage, SQL, etc. or your own Private Link Service.

Example Usage

resources:
  example:
    type: azure:core:ResourceGroup
    properties:
      name: example-resources
      location: West Europe
  exampleVirtualNetwork:
    type: azure:network:VirtualNetwork
    name: example
    properties:
      name: example-network
      addressSpaces:
        - 10.0.0.0/16
      location: ${example.location}
      resourceGroupName: ${example.name}
  service:
    type: azure:network:Subnet
    properties:
      name: service
      resourceGroupName: ${example.name}
      virtualNetworkName: ${exampleVirtualNetwork.name}
      addressPrefixes:
        - 10.0.1.0/24
      enforcePrivateLinkServiceNetworkPolicies: true
  endpoint:
    type: azure:network:Subnet
    properties:
      name: endpoint
      resourceGroupName: ${example.name}
      virtualNetworkName: ${exampleVirtualNetwork.name}
      addressPrefixes:
        - 10.0.2.0/24
      enforcePrivateLinkEndpointNetworkPolicies: true
  examplePublicIp:
    type: azure:network:PublicIp
    name: example
    properties:
      name: example-pip
      sku: Standard
      location: ${example.location}
      resourceGroupName: ${example.name}
      allocationMethod: Static
  exampleLoadBalancer:
    type: azure:lb:LoadBalancer
    name: example
    properties:
      name: example-lb
      sku: Standard
      location: ${example.location}
      resourceGroupName: ${example.name}
      frontendIpConfigurations:
        - name: ${examplePublicIp.name}
          publicIpAddressId: ${examplePublicIp.id}
  exampleLinkService:
    type: azure:privatedns:LinkService
    name: example
    properties:
      name: example-privatelink
      location: ${example.location}
      resourceGroupName: ${example.name}
      natIpConfigurations:
        - name: ${examplePublicIp.name}
          primary: true
          subnetId: ${service.id}
      loadBalancerFrontendIpConfigurationIds:
        - ${exampleLoadBalancer.frontendIpConfigurations[0].id}
  exampleEndpoint:
    type: azure:privatelink:Endpoint
    name: example
    properties:
      name: example-endpoint
      location: ${example.location}
      resourceGroupName: ${example.name}
      subnetId: ${endpoint.id}
      privateServiceConnection:
        name: example-privateserviceconnection
        privateConnectionResourceId: ${exampleLinkService.id}
        isManualConnection: false
Content copied to clipboard

Using a Private Link Service Alias with existing resources:

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";
const example = azure.core.getResourceGroup({
    name: "example-resources",
});
const vnet = example.then(example => azure.network.getVirtualNetwork({
    name: "example-network",
    resourceGroupName: example.name,
}));
const subnet = Promise.all([vnet, example])&#46;then(([vnet, example]) => azure.network.getSubnet({
    name: "default",
    virtualNetworkName: vnet.name,
    resourceGroupName: example.name,
}));
const exampleEndpoint = new azure.privatelink.Endpoint("example", {
    name: "example-endpoint",
    location: example.then(example => example.location),
    resourceGroupName: example.then(example => example.name),
    subnetId: subnet.then(subnet => subnet.id),
    privateServiceConnection: {
        name: "example-privateserviceconnection",
        privateConnectionResourceAlias: "example-privatelinkservice.d20286c8-4ea5-11eb-9584-8f53157226c6.centralus.azure.privatelinkservice",
        isManualConnection: true,
        requestMessage: "PL",
    },
});
Content copied to clipboard
import pulumi
import pulumi_azure as azure
example = azure.core.get_resource_group(name="example-resources")
vnet = azure.network.get_virtual_network(name="example-network",
    resource_group_name=example.name)
subnet = azure.network.get_subnet(name="default",
    virtual_network_name=vnet.name,
    resource_group_name=example.name)
example_endpoint = azure.privatelink.Endpoint("example",
    name="example-endpoint",
    location=example.location,
    resource_group_name=example.name,
    subnet_id=subnet.id,
    private_service_connection={
        "name": "example-privateserviceconnection",
        "private_connection_resource_alias": "example-privatelinkservice.d20286c8-4ea5-11eb-9584-8f53157226c6.centralus.azure.privatelinkservice",
        "is_manual_connection": True,
        "request_message": "PL",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;
return await Deployment.RunAsync(() =>
{
    var example = Azure.Core.GetResourceGroup.Invoke(new()
    {
        Name = "example-resources",
    });
    var vnet = Azure.Network.GetVirtualNetwork.Invoke(new()
    {
        Name = "example-network",
        ResourceGroupName = example.Apply(getResourceGroupResult => getResourceGroupResult.Name),
    });
    var subnet = Azure.Network.GetSubnet.Invoke(new()
    {
        Name = "default",
        VirtualNetworkName = vnet.Apply(getVirtualNetworkResult => getVirtualNetworkResult.Name),
        ResourceGroupName = example.Apply(getResourceGroupResult => getResourceGroupResult.Name),
    });
    var exampleEndpoint = new Azure.PrivateLink.Endpoint("example", new()
    {
        Name = "example-endpoint",
        Location = example.Apply(getResourceGroupResult => getResourceGroupResult.Location),
        ResourceGroupName = example.Apply(getResourceGroupResult => getResourceGroupResult.Name),
        SubnetId = subnet.Apply(getSubnetResult => getSubnetResult.Id),
        PrivateServiceConnection = new Azure.PrivateLink.Inputs.EndpointPrivateServiceConnectionArgs
        {
            Name = "example-privateserviceconnection",
            PrivateConnectionResourceAlias = "example-privatelinkservice.d20286c8-4ea5-11eb-9584-8f53157226c6.centralus.azure.privatelinkservice",
            IsManualConnection = true,
            RequestMessage = "PL",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/network"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/privatelink"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := core.LookupResourceGroup(ctx, &core.LookupResourceGroupArgs{
			Name: "example-resources",
		}, nil)
		if err != nil {
			return err
		}
		vnet, err := network.LookupVirtualNetwork(ctx, &network.LookupVirtualNetworkArgs{
			Name:              "example-network",
			ResourceGroupName: example.Name,
		}, nil)
		if err != nil {
			return err
		}
		subnet, err := network.LookupSubnet(ctx, &network.LookupSubnetArgs{
			Name:               "default",
			VirtualNetworkName: vnet.Name,
			ResourceGroupName:  example.Name,
		}, nil)
		if err != nil {
			return err
		}
		_, err = privatelink.NewEndpoint(ctx, "example", &privatelink.EndpointArgs{
			Name:              pulumi.String("example-endpoint"),
			Location:          pulumi.String(example.Location),
			ResourceGroupName: pulumi.String(example.Name),
			SubnetId:          pulumi.String(subnet.Id),
			PrivateServiceConnection: &privatelink.EndpointPrivateServiceConnectionArgs{
				Name:                           pulumi.String("example-privateserviceconnection"),
				PrivateConnectionResourceAlias: pulumi.String("example-privatelinkservice.d20286c8-4ea5-11eb-9584-8f53157226c6.centralus.azure.privatelinkservice"),
				IsManualConnection:             pulumi.Bool(true),
				RequestMessage:                 pulumi.String("PL"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azure.core.CoreFunctions;
import com.pulumi.azure.core.inputs.GetResourceGroupArgs;
import com.pulumi.azure.network.NetworkFunctions;
import com.pulumi.azure.network.inputs.GetVirtualNetworkArgs;
import com.pulumi.azure.network.inputs.GetSubnetArgs;
import com.pulumi.azure.privatelink.Endpoint;
import com.pulumi.azure.privatelink.EndpointArgs;
import com.pulumi.azure.privatelink.inputs.EndpointPrivateServiceConnectionArgs;
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 example = CoreFunctions.getResourceGroup(GetResourceGroupArgs.builder()
            .name("example-resources")
            .build());
        final var vnet = NetworkFunctions.getVirtualNetwork(GetVirtualNetworkArgs.builder()
            .name("example-network")
            .resourceGroupName(example.applyValue(getResourceGroupResult -> getResourceGroupResult.name()))
            .build());
        final var subnet = NetworkFunctions.getSubnet(GetSubnetArgs.builder()
            .name("default")
            .virtualNetworkName(vnet.applyValue(getVirtualNetworkResult -> getVirtualNetworkResult.name()))
            .resourceGroupName(example.applyValue(getResourceGroupResult -> getResourceGroupResult.name()))
            .build());
        var exampleEndpoint = new Endpoint("exampleEndpoint", EndpointArgs.builder()
            .name("example-endpoint")
            .location(example.applyValue(getResourceGroupResult -> getResourceGroupResult.location()))
            .resourceGroupName(example.applyValue(getResourceGroupResult -> getResourceGroupResult.name()))
            .subnetId(subnet.applyValue(getSubnetResult -> getSubnetResult.id()))
            .privateServiceConnection(EndpointPrivateServiceConnectionArgs.builder()
                .name("example-privateserviceconnection")
                .privateConnectionResourceAlias("example-privatelinkservice.d20286c8-4ea5-11eb-9584-8f53157226c6.centralus.azure.privatelinkservice")
                .isManualConnection(true)
                .requestMessage("PL")
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  exampleEndpoint:
    type: azure:privatelink:Endpoint
    name: example
    properties:
      name: example-endpoint
      location: ${example.location}
      resourceGroupName: ${example.name}
      subnetId: ${subnet.id}
      privateServiceConnection:
        name: example-privateserviceconnection
        privateConnectionResourceAlias: example-privatelinkservice.d20286c8-4ea5-11eb-9584-8f53157226c6.centralus.azure.privatelinkservice
        isManualConnection: true
        requestMessage: PL
variables:
  example:
    fn::invoke:
      function: azure:core:getResourceGroup
      arguments:
        name: example-resources
  vnet:
    fn::invoke:
      function: azure:network:getVirtualNetwork
      arguments:
        name: example-network
        resourceGroupName: ${example.name}
  subnet:
    fn::invoke:
      function: azure:network:getSubnet
      arguments:
        name: default
        virtualNetworkName: ${vnet.name}
        resourceGroupName: ${example.name}
Content copied to clipboard

Using a Private Endpoint pointing to an owned Azure service, with proper DNS configuration:

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";
const example = new azure.core.ResourceGroup("example", {
    name: "example-rg",
    location: "West Europe",
});
const exampleAccount = new azure.storage.Account("example", {
    name: "exampleaccount",
    resourceGroupName: example.name,
    location: example.location,
    accountTier: "Standard",
    accountReplicationType: "LRS",
});
const exampleVirtualNetwork = new azure.network.VirtualNetwork("example", {
    name: "virtnetname",
    addressSpaces: ["10&#46;0&#46;0&#46;0/16"],
    location: example.location,
    resourceGroupName: example.name,
});
const exampleSubnet = new azure.network.Subnet("example", {
    name: "subnetname",
    resourceGroupName: example.name,
    virtualNetworkName: exampleVirtualNetwork.name,
    addressPrefixes: ["10&#46;0&#46;2&#46;0/24"],
});
const exampleZone = new azure.privatedns.Zone("example", {
    name: "privatelink.blob.core.windows.net",
    resourceGroupName: example.name,
});
const exampleEndpoint = new azure.privatelink.Endpoint("example", {
    name: "example-endpoint",
    location: example.location,
    resourceGroupName: example.name,
    subnetId: exampleSubnet.id,
    privateServiceConnection: {
        name: "example-privateserviceconnection",
        privateConnectionResourceId: exampleAccount.id,
        subresourceNames: ["blob"],
        isManualConnection: false,
    },
    privateDnsZoneGroup: {
        name: "example-dns-zone-group",
        privateDnsZoneIds: [exampleZone&#46;id],
    },
});
const exampleZoneVirtualNetworkLink = new azure.privatedns.ZoneVirtualNetworkLink("example", {
    name: "example-link",
    resourceGroupName: example.name,
    privateDnsZoneName: exampleZone.name,
    virtualNetworkId: exampleVirtualNetwork.id,
});
Content copied to clipboard
import pulumi
import pulumi_azure as azure
example = azure.core.ResourceGroup("example",
    name="example-rg",
    location="West Europe")
example_account = azure.storage.Account("example",
    name="exampleaccount",
    resource_group_name=example.name,
    location=example.location,
    account_tier="Standard",
    account_replication_type="LRS")
example_virtual_network = azure.network.VirtualNetwork("example",
    name="virtnetname",
    address_spaces=["10&#46;0&#46;0&#46;0/16"],
    location=example.location,
    resource_group_name=example.name)
example_subnet = azure.network.Subnet("example",
    name="subnetname",
    resource_group_name=example.name,
    virtual_network_name=example_virtual_network.name,
    address_prefixes=["10&#46;0&#46;2&#46;0/24"])
example_zone = azure.privatedns.Zone("example",
    name="privatelink.blob.core.windows.net",
    resource_group_name=example.name)
example_endpoint = azure.privatelink.Endpoint("example",
    name="example-endpoint",
    location=example.location,
    resource_group_name=example.name,
    subnet_id=example_subnet.id,
    private_service_connection={
        "name": "example-privateserviceconnection",
        "private_connection_resource_id": example_account.id,
        "subresource_names": ["blob"],
        "is_manual_connection": False,
    },
    private_dns_zone_group={
        "name": "example-dns-zone-group",
        "private_dns_zone_ids": [example_zone&#46;id],
    })
example_zone_virtual_network_link = azure.privatedns.ZoneVirtualNetworkLink("example",
    name="example-link",
    resource_group_name=example.name,
    private_dns_zone_name=example_zone.name,
    virtual_network_id=example_virtual_network.id)
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;
return await Deployment.RunAsync(() =>
{
    var example = new Azure.Core.ResourceGroup("example", new()
    {
        Name = "example-rg",
        Location = "West Europe",
    });
    var exampleAccount = new Azure.Storage.Account("example", new()
    {
        Name = "exampleaccount",
        ResourceGroupName = example.Name,
        Location = example.Location,
        AccountTier = "Standard",
        AccountReplicationType = "LRS",
    });
    var exampleVirtualNetwork = new Azure.Network.VirtualNetwork("example", new()
    {
        Name = "virtnetname",
        AddressSpaces = new[]
        {
            "10.0.0.0/16",
        },
        Location = example.Location,
        ResourceGroupName = example.Name,
    });
    var exampleSubnet = new Azure.Network.Subnet("example", new()
    {
        Name = "subnetname",
        ResourceGroupName = example.Name,
        VirtualNetworkName = exampleVirtualNetwork.Name,
        AddressPrefixes = new[]
        {
            "10.0.2.0/24",
        },
    });
    var exampleZone = new Azure.PrivateDns.Zone("example", new()
    {
        Name = "privatelink.blob.core.windows.net",
        ResourceGroupName = example.Name,
    });
    var exampleEndpoint = new Azure.PrivateLink.Endpoint("example", new()
    {
        Name = "example-endpoint",
        Location = example.Location,
        ResourceGroupName = example.Name,
        SubnetId = exampleSubnet.Id,
        PrivateServiceConnection = new Azure.PrivateLink.Inputs.EndpointPrivateServiceConnectionArgs
        {
            Name = "example-privateserviceconnection",
            PrivateConnectionResourceId = exampleAccount.Id,
            SubresourceNames = new[]
            {
                "blob",
            },
            IsManualConnection = false,
        },
        PrivateDnsZoneGroup = new Azure.PrivateLink.Inputs.EndpointPrivateDnsZoneGroupArgs
        {
            Name = "example-dns-zone-group",
            PrivateDnsZoneIds = new[]
            {
                exampleZone.Id,
            },
        },
    });
    var exampleZoneVirtualNetworkLink = new Azure.PrivateDns.ZoneVirtualNetworkLink("example", new()
    {
        Name = "example-link",
        ResourceGroupName = example.Name,
        PrivateDnsZoneName = exampleZone.Name,
        VirtualNetworkId = exampleVirtualNetwork.Id,
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/network"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/privatedns"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/privatelink"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/storage"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := core.NewResourceGroup(ctx, "example", &core.ResourceGroupArgs{
			Name:     pulumi.String("example-rg"),
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		exampleAccount, err := storage.NewAccount(ctx, "example", &storage.AccountArgs{
			Name:                   pulumi.String("exampleaccount"),
			ResourceGroupName:      example.Name,
			Location:               example.Location,
			AccountTier:            pulumi.String("Standard"),
			AccountReplicationType: pulumi.String("LRS"),
		})
		if err != nil {
			return err
		}
		exampleVirtualNetwork, err := network.NewVirtualNetwork(ctx, "example", &network.VirtualNetworkArgs{
			Name: pulumi.String("virtnetname"),
			AddressSpaces: pulumi.StringArray{
				pulumi.String("10.0.0.0/16"),
			},
			Location:          example.Location,
			ResourceGroupName: example.Name,
		})
		if err != nil {
			return err
		}
		exampleSubnet, err := network.NewSubnet(ctx, "example", &network.SubnetArgs{
			Name:               pulumi.String("subnetname"),
			ResourceGroupName:  example.Name,
			VirtualNetworkName: exampleVirtualNetwork.Name,
			AddressPrefixes: pulumi.StringArray{
				pulumi.String("10.0.2.0/24"),
			},
		})
		if err != nil {
			return err
		}
		exampleZone, err := privatedns.NewZone(ctx, "example", &privatedns.ZoneArgs{
			Name:              pulumi.String("privatelink.blob.core.windows.net"),
			ResourceGroupName: example.Name,
		})
		if err != nil {
			return err
		}
		_, err = privatelink.NewEndpoint(ctx, "example", &privatelink.EndpointArgs{
			Name:              pulumi.String("example-endpoint"),
			Location:          example.Location,
			ResourceGroupName: example.Name,
			SubnetId:          exampleSubnet.ID(),
			PrivateServiceConnection: &privatelink.EndpointPrivateServiceConnectionArgs{
				Name:                        pulumi.String("example-privateserviceconnection"),
				PrivateConnectionResourceId: exampleAccount.ID(),
				SubresourceNames: pulumi.StringArray{
					pulumi.String("blob"),
				},
				IsManualConnection: pulumi.Bool(false),
			},
			PrivateDnsZoneGroup: &privatelink.EndpointPrivateDnsZoneGroupArgs{
				Name: pulumi.String("example-dns-zone-group"),
				PrivateDnsZoneIds: pulumi.StringArray{
					exampleZone.ID(),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = privatedns.NewZoneVirtualNetworkLink(ctx, "example", &privatedns.ZoneVirtualNetworkLinkArgs{
			Name:               pulumi.String("example-link"),
			ResourceGroupName:  example.Name,
			PrivateDnsZoneName: exampleZone.Name,
			VirtualNetworkId:   exampleVirtualNetwork.ID(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azure.core.ResourceGroup;
import com.pulumi.azure.core.ResourceGroupArgs;
import com.pulumi.azure.storage.Account;
import com.pulumi.azure.storage.AccountArgs;
import com.pulumi.azure.network.VirtualNetwork;
import com.pulumi.azure.network.VirtualNetworkArgs;
import com.pulumi.azure.network.Subnet;
import com.pulumi.azure.network.SubnetArgs;
import com.pulumi.azure.privatedns.Zone;
import com.pulumi.azure.privatedns.ZoneArgs;
import com.pulumi.azure.privatelink.Endpoint;
import com.pulumi.azure.privatelink.EndpointArgs;
import com.pulumi.azure.privatelink.inputs.EndpointPrivateServiceConnectionArgs;
import com.pulumi.azure.privatelink.inputs.EndpointPrivateDnsZoneGroupArgs;
import com.pulumi.azure.privatedns.ZoneVirtualNetworkLink;
import com.pulumi.azure.privatedns.ZoneVirtualNetworkLinkArgs;
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) {
        var example = new ResourceGroup("example", ResourceGroupArgs.builder()
            .name("example-rg")
            .location("West Europe")
            .build());
        var exampleAccount = new Account("exampleAccount", AccountArgs.builder()
            .name("exampleaccount")
            .resourceGroupName(example.name())
            .location(example.location())
            .accountTier("Standard")
            .accountReplicationType("LRS")
            .build());
        var exampleVirtualNetwork = new VirtualNetwork("exampleVirtualNetwork", VirtualNetworkArgs.builder()
            .name("virtnetname")
            .addressSpaces("10.0.0.0/16")
            .location(example.location())
            .resourceGroupName(example.name())
            .build());
        var exampleSubnet = new Subnet("exampleSubnet", SubnetArgs.builder()
            .name("subnetname")
            .resourceGroupName(example.name())
            .virtualNetworkName(exampleVirtualNetwork.name())
            .addressPrefixes("10.0.2.0/24")
            .build());
        var exampleZone = new Zone("exampleZone", ZoneArgs.builder()
            .name("privatelink.blob.core.windows.net")
            .resourceGroupName(example.name())
            .build());
        var exampleEndpoint = new Endpoint("exampleEndpoint", EndpointArgs.builder()
            .name("example-endpoint")
            .location(example.location())
            .resourceGroupName(example.name())
            .subnetId(exampleSubnet.id())
            .privateServiceConnection(EndpointPrivateServiceConnectionArgs.builder()
                .name("example-privateserviceconnection")
                .privateConnectionResourceId(exampleAccount.id())
                .subresourceNames("blob")
                .isManualConnection(false)
                .build())
            .privateDnsZoneGroup(EndpointPrivateDnsZoneGroupArgs.builder()
                .name("example-dns-zone-group")
                .privateDnsZoneIds(exampleZone.id())
                .build())
            .build());
        var exampleZoneVirtualNetworkLink = new ZoneVirtualNetworkLink("exampleZoneVirtualNetworkLink", ZoneVirtualNetworkLinkArgs.builder()
            .name("example-link")
            .resourceGroupName(example.name())
            .privateDnsZoneName(exampleZone.name())
            .virtualNetworkId(exampleVirtualNetwork.id())
            .build());
    }
}
Content copied to clipboard
resources:
  example:
    type: azure:core:ResourceGroup
    properties:
      name: example-rg
      location: West Europe
  exampleAccount:
    type: azure:storage:Account
    name: example
    properties:
      name: exampleaccount
      resourceGroupName: ${example.name}
      location: ${example.location}
      accountTier: Standard
      accountReplicationType: LRS
  exampleVirtualNetwork:
    type: azure:network:VirtualNetwork
    name: example
    properties:
      name: virtnetname
      addressSpaces:
        - 10.0.0.0/16
      location: ${example.location}
      resourceGroupName: ${example.name}
  exampleSubnet:
    type: azure:network:Subnet
    name: example
    properties:
      name: subnetname
      resourceGroupName: ${example.name}
      virtualNetworkName: ${exampleVirtualNetwork.name}
      addressPrefixes:
        - 10.0.2.0/24
  exampleEndpoint:
    type: azure:privatelink:Endpoint
    name: example
    properties:
      name: example-endpoint
      location: ${example.location}
      resourceGroupName: ${example.name}
      subnetId: ${exampleSubnet.id}
      privateServiceConnection:
        name: example-privateserviceconnection
        privateConnectionResourceId: ${exampleAccount.id}
        subresourceNames:
          - blob
        isManualConnection: false
      privateDnsZoneGroup:
        name: example-dns-zone-group
        privateDnsZoneIds:
          - ${exampleZone.id}
  exampleZone:
    type: azure:privatedns:Zone
    name: example
    properties:
      name: privatelink.blob.core.windows.net
      resourceGroupName: ${example.name}
  exampleZoneVirtualNetworkLink:
    type: azure:privatedns:ZoneVirtualNetworkLink
    name: example
    properties:
      name: example-link
      resourceGroupName: ${example.name}
      privateDnsZoneName: ${exampleZone.name}
      virtualNetworkId: ${exampleVirtualNetwork.id}
Content copied to clipboard

Example HCL Configurations

  • How to conneca Private Endpoint to a Application Gateway

  • How to connect a Private Endpoint to a Cosmos MongoDB

  • How to connect a Private Endpoint to a Cosmos PostgreSQL

  • How to connect a Private Endpoint to a PostgreSQL Server

  • How to connect a Private Endpoint to a Private Link Service

  • How to connect a Private Endpoint to a Private DNS Group

  • How to connect a Private Endpoint to a Databricks Workspace

Import

Private Endpoints can be imported using the resource id, e.g.

$ pulumi import azure:privatelink/endpoint:Endpoint example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.Network/privateEndpoints/endpoint1
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(customNetworkInterfaceName: Output<String>? = null, ipConfigurations: Output<List<EndpointIpConfigurationArgs>>? = null, location: Output<String>? = null, name: Output<String>? = null, privateDnsZoneGroup: Output<EndpointPrivateDnsZoneGroupArgs>? = null, privateServiceConnection: Output<EndpointPrivateServiceConnectionArgs>? = null, resourceGroupName: Output<String>? = null, subnetId: Output<String>? = null, tags: Output<Map<String, String>>? = null)

Properties

Link copied to clipboard
val customNetworkInterfaceName: Output<String>? = null

The custom name of the network interface attached to the private endpoint. Changing this forces a new resource to be created.

Link copied to clipboard
val ipConfigurations: Output<List<EndpointIpConfigurationArgs>>? = null

One or more ip_configuration blocks as defined below. This allows a static IP address to be set for this Private Endpoint, otherwise an address is dynamically allocated from the Subnet.

Link copied to clipboard
val location: Output<String>? = null

The supported Azure location where the resource exists. Changing this forces a new resource to be created.

Link copied to clipboard
val name: Output<String>? = null

Specifies the Name of the Private Endpoint. Changing this forces a new resource to be created.

Link copied to clipboard
val privateDnsZoneGroup: Output<EndpointPrivateDnsZoneGroupArgs>? = null

A private_dns_zone_group block as defined below.

Link copied to clipboard
val privateServiceConnection: Output<EndpointPrivateServiceConnectionArgs>? = null

A private_service_connection block as defined below.

Link copied to clipboard
val resourceGroupName: Output<String>? = null

Specifies the Name of the Resource Group within which the Private Endpoint should exist. Changing this forces a new resource to be created.

Link copied to clipboard
val subnetId: Output<String>? = null

The ID of the Subnet from which Private IP Addresses will be allocated for this Private Endpoint. Changing this forces a new resource to be created.

Link copied to clipboard
val tags: Output<Map<String, String>>? = null

A mapping of tags to assign to the resource.

Functions

Link copied to clipboard
open override fun toJava(): EndpointArgs