privatelink

package
v5.88.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 19, 2024 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type ApplicationSecurityGroupAssociation added in v5.31.0 

type ApplicationSecurityGroupAssociation struct {
	pulumi.CustomResourceState

	// The id of application security group to associate. Changing this forces a new resource to be created.
	ApplicationSecurityGroupId pulumi.StringOutput `pulumi:"applicationSecurityGroupId"`
	// The id of private endpoint to associate. Changing this forces a new resource to be created.
	PrivateEndpointId pulumi.StringOutput `pulumi:"privateEndpointId"`
}

Manages an association between Private Endpoint and Application Security Group.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/lb"
"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/network"
"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/privatedns"
"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/privatelink"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		current, err := core.LookupSubscription(ctx, nil, nil)
		if err != nil {
			return err
		}
		example, err := core.NewResourceGroup(ctx, "example", &core.ResourceGroupArgs{
			Name:     pulumi.String("example-PEASGAsso"),
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		exampleVirtualNetwork, err := network.NewVirtualNetwork(ctx, "example", &network.VirtualNetworkArgs{
			Name:              pulumi.String("examplevnet"),
			ResourceGroupName: example.Name,
			Location:          example.Location,
			AddressSpaces: pulumi.StringArray{
				pulumi.String("10.5.0.0/16"),
			},
		})
		if err != nil {
			return err
		}
		service, err := network.NewSubnet(ctx, "service", &network.SubnetArgs{
			Name:               pulumi.String("examplenetservice"),
			ResourceGroupName:  example.Name,
			VirtualNetworkName: exampleVirtualNetwork.Name,
			AddressPrefixes: pulumi.StringArray{
				pulumi.String("10.5.1.0/24"),
			},
			EnforcePrivateLinkServiceNetworkPolicies: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		endpoint, err := network.NewSubnet(ctx, "endpoint", &network.SubnetArgs{
			Name:               pulumi.String("examplenetendpoint"),
			ResourceGroupName:  example.Name,
			VirtualNetworkName: exampleVirtualNetwork.Name,
			AddressPrefixes: pulumi.StringArray{
				pulumi.String("10.5.2.0/24"),
			},
			EnforcePrivateLinkEndpointNetworkPolicies: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		examplePublicIp, err := network.NewPublicIp(ctx, "example", &network.PublicIpArgs{
			Name:              pulumi.String("examplepip"),
			Sku:               pulumi.String("Standard"),
			Location:          example.Location,
			ResourceGroupName: example.Name,
			AllocationMethod:  pulumi.String("Static"),
		})
		if err != nil {
			return err
		}
		exampleLoadBalancer, err := lb.NewLoadBalancer(ctx, "example", &lb.LoadBalancerArgs{
			Name:              pulumi.String("examplelb"),
			Sku:               pulumi.String("Standard"),
			Location:          example.Location,
			ResourceGroupName: example.Name,
			FrontendIpConfigurations: lb.LoadBalancerFrontendIpConfigurationArray{
				&lb.LoadBalancerFrontendIpConfigurationArgs{
					Name:              examplePublicIp.Name,
					PublicIpAddressId: examplePublicIp.ID(),
				},
			},
		})
		if err != nil {
			return err
		}
		exampleLinkService, err := privatedns.NewLinkService(ctx, "example", &privatedns.LinkServiceArgs{
			Name:              pulumi.String("examplePLS"),
			Location:          example.Location,
			ResourceGroupName: example.Name,
			AutoApprovalSubscriptionIds: pulumi.StringArray{
				pulumi.String(current.SubscriptionId),
			},
			VisibilitySubscriptionIds: pulumi.StringArray{
				pulumi.String(current.SubscriptionId),
			},
			NatIpConfigurations: privatedns.LinkServiceNatIpConfigurationArray{
				&privatedns.LinkServiceNatIpConfigurationArgs{
					Name:     pulumi.String("primaryIpConfiguration"),
					Primary:  pulumi.Bool(true),
					SubnetId: service.ID(),
				},
			},
			LoadBalancerFrontendIpConfigurationIds: pulumi.StringArray{
				pulumi.String(exampleLoadBalancer.FrontendIpConfigurations.ApplyT(func(frontendIpConfigurations []lb.LoadBalancerFrontendIpConfiguration) (*string, error) {
					return &frontendIpConfigurations[0].Id, nil
				}).(pulumi.StringPtrOutput)),
			},
		})
		if err != nil {
			return err
		}
		exampleEndpoint, err := privatelink.NewEndpoint(ctx, "example", &privatelink.EndpointArgs{
			Name:              pulumi.String("example-privatelink"),
			ResourceGroupName: example.Name,
			Location:          example.Location,
			SubnetId:          endpoint.ID(),
			PrivateServiceConnection: &privatelink.EndpointPrivateServiceConnectionArgs{
				Name:                        exampleLinkService.Name,
				IsManualConnection:          pulumi.Bool(false),
				PrivateConnectionResourceId: exampleLinkService.ID(),
			},
		})
		if err != nil {
			return err
		}
		exampleApplicationSecurityGroup, err := network.NewApplicationSecurityGroup(ctx, "example", &network.ApplicationSecurityGroupArgs{
			Name:              pulumi.String("example"),
			Location:          example.Location,
			ResourceGroupName: example.Name,
		})
		if err != nil {
			return err
		}
		_, err = privatelink.NewApplicationSecurityGroupAssociation(ctx, "example", &privatelink.ApplicationSecurityGroupAssociationArgs{
			PrivateEndpointId:          exampleEndpoint.ID(),
			ApplicationSecurityGroupId: exampleApplicationSecurityGroup.ID(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Associations between Private Endpoint and Application Security Group can be imported using the `resource id`, e.g.

```sh $ pulumi import azure:privatelink/applicationSecurityGroupAssociation:ApplicationSecurityGroupAssociation association1 "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.Network/privateEndpoints/endpoints1|/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/mygroup1/providers/Microsoft.Network/applicationSecurityGroups/securityGroup1", ```

func GetApplicationSecurityGroupAssociation added in v5.31.0 

func GetApplicationSecurityGroupAssociation(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ApplicationSecurityGroupAssociationState, opts ...pulumi.ResourceOption) (*ApplicationSecurityGroupAssociation, error)

GetApplicationSecurityGroupAssociation gets an existing ApplicationSecurityGroupAssociation resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewApplicationSecurityGroupAssociation added in v5.31.0 

func NewApplicationSecurityGroupAssociation(ctx *pulumi.Context,
	name string, args *ApplicationSecurityGroupAssociationArgs, opts ...pulumi.ResourceOption) (*ApplicationSecurityGroupAssociation, error)

NewApplicationSecurityGroupAssociation registers a new resource with the given unique name, arguments, and options.

func (*ApplicationSecurityGroupAssociation) ElementType added in v5.31.0 

func (*ApplicationSecurityGroupAssociation) ElementType() reflect.Type

func (*ApplicationSecurityGroupAssociation) ToApplicationSecurityGroupAssociationOutput added in v5.31.0 

func (i *ApplicationSecurityGroupAssociation) ToApplicationSecurityGroupAssociationOutput() ApplicationSecurityGroupAssociationOutput

func (*ApplicationSecurityGroupAssociation) ToApplicationSecurityGroupAssociationOutputWithContext added in v5.31.0 

func (i *ApplicationSecurityGroupAssociation) ToApplicationSecurityGroupAssociationOutputWithContext(ctx context.Context) ApplicationSecurityGroupAssociationOutput

type ApplicationSecurityGroupAssociationArgs added in v5.31.0 

type ApplicationSecurityGroupAssociationArgs struct {
	// The id of application security group to associate. Changing this forces a new resource to be created.
	ApplicationSecurityGroupId pulumi.StringInput
	// The id of private endpoint to associate. Changing this forces a new resource to be created.
	PrivateEndpointId pulumi.StringInput
}

The set of arguments for constructing a ApplicationSecurityGroupAssociation resource.

func (ApplicationSecurityGroupAssociationArgs) ElementType added in v5.31.0 

func (ApplicationSecurityGroupAssociationArgs) ElementType() reflect.Type

type ApplicationSecurityGroupAssociationArray added in v5.31.0 

type ApplicationSecurityGroupAssociationArray []ApplicationSecurityGroupAssociationInput

func (ApplicationSecurityGroupAssociationArray) ElementType added in v5.31.0 

func (ApplicationSecurityGroupAssociationArray) ElementType() reflect.Type

func (ApplicationSecurityGroupAssociationArray) ToApplicationSecurityGroupAssociationArrayOutput added in v5.31.0 

func (i ApplicationSecurityGroupAssociationArray) ToApplicationSecurityGroupAssociationArrayOutput() ApplicationSecurityGroupAssociationArrayOutput

func (ApplicationSecurityGroupAssociationArray) ToApplicationSecurityGroupAssociationArrayOutputWithContext added in v5.31.0 

func (i ApplicationSecurityGroupAssociationArray) ToApplicationSecurityGroupAssociationArrayOutputWithContext(ctx context.Context) ApplicationSecurityGroupAssociationArrayOutput

type ApplicationSecurityGroupAssociationArrayInput added in v5.31.0 

type ApplicationSecurityGroupAssociationArrayInput interface {
	pulumi.Input

	ToApplicationSecurityGroupAssociationArrayOutput() ApplicationSecurityGroupAssociationArrayOutput
	ToApplicationSecurityGroupAssociationArrayOutputWithContext(context.Context) ApplicationSecurityGroupAssociationArrayOutput
}

ApplicationSecurityGroupAssociationArrayInput is an input type that accepts ApplicationSecurityGroupAssociationArray and ApplicationSecurityGroupAssociationArrayOutput values. You can construct a concrete instance of `ApplicationSecurityGroupAssociationArrayInput` via: 

ApplicationSecurityGroupAssociationArray{ ApplicationSecurityGroupAssociationArgs{...} }

type ApplicationSecurityGroupAssociationArrayOutput added in v5.31.0 

type ApplicationSecurityGroupAssociationArrayOutput struct{ *pulumi.OutputState }

func (ApplicationSecurityGroupAssociationArrayOutput) ElementType added in v5.31.0 

func (ApplicationSecurityGroupAssociationArrayOutput) ElementType() reflect.Type

func (ApplicationSecurityGroupAssociationArrayOutput) Index added in v5.31.0 

func (o ApplicationSecurityGroupAssociationArrayOutput) Index(i pulumi.IntInput) ApplicationSecurityGroupAssociationOutput

func (ApplicationSecurityGroupAssociationArrayOutput) ToApplicationSecurityGroupAssociationArrayOutput added in v5.31.0 

func (o ApplicationSecurityGroupAssociationArrayOutput) ToApplicationSecurityGroupAssociationArrayOutput() ApplicationSecurityGroupAssociationArrayOutput

func (ApplicationSecurityGroupAssociationArrayOutput) ToApplicationSecurityGroupAssociationArrayOutputWithContext added in v5.31.0 

func (o ApplicationSecurityGroupAssociationArrayOutput) ToApplicationSecurityGroupAssociationArrayOutputWithContext(ctx context.Context) ApplicationSecurityGroupAssociationArrayOutput

type ApplicationSecurityGroupAssociationInput added in v5.31.0 

type ApplicationSecurityGroupAssociationInput interface {
	pulumi.Input

	ToApplicationSecurityGroupAssociationOutput() ApplicationSecurityGroupAssociationOutput
	ToApplicationSecurityGroupAssociationOutputWithContext(ctx context.Context) ApplicationSecurityGroupAssociationOutput
}

type ApplicationSecurityGroupAssociationMap added in v5.31.0 

type ApplicationSecurityGroupAssociationMap map[string]ApplicationSecurityGroupAssociationInput

func (ApplicationSecurityGroupAssociationMap) ElementType added in v5.31.0 

func (ApplicationSecurityGroupAssociationMap) ElementType() reflect.Type

func (ApplicationSecurityGroupAssociationMap) ToApplicationSecurityGroupAssociationMapOutput added in v5.31.0 

func (i ApplicationSecurityGroupAssociationMap) ToApplicationSecurityGroupAssociationMapOutput() ApplicationSecurityGroupAssociationMapOutput

func (ApplicationSecurityGroupAssociationMap) ToApplicationSecurityGroupAssociationMapOutputWithContext added in v5.31.0 

func (i ApplicationSecurityGroupAssociationMap) ToApplicationSecurityGroupAssociationMapOutputWithContext(ctx context.Context) ApplicationSecurityGroupAssociationMapOutput

type ApplicationSecurityGroupAssociationMapInput added in v5.31.0 

type ApplicationSecurityGroupAssociationMapInput interface {
	pulumi.Input

	ToApplicationSecurityGroupAssociationMapOutput() ApplicationSecurityGroupAssociationMapOutput
	ToApplicationSecurityGroupAssociationMapOutputWithContext(context.Context) ApplicationSecurityGroupAssociationMapOutput
}

ApplicationSecurityGroupAssociationMapInput is an input type that accepts ApplicationSecurityGroupAssociationMap and ApplicationSecurityGroupAssociationMapOutput values. You can construct a concrete instance of `ApplicationSecurityGroupAssociationMapInput` via: 

ApplicationSecurityGroupAssociationMap{ "key": ApplicationSecurityGroupAssociationArgs{...} }

type ApplicationSecurityGroupAssociationMapOutput added in v5.31.0 

type ApplicationSecurityGroupAssociationMapOutput struct{ *pulumi.OutputState }

func (ApplicationSecurityGroupAssociationMapOutput) ElementType added in v5.31.0 

func (ApplicationSecurityGroupAssociationMapOutput) ElementType() reflect.Type

func (ApplicationSecurityGroupAssociationMapOutput) MapIndex added in v5.31.0 

func (o ApplicationSecurityGroupAssociationMapOutput) MapIndex(k pulumi.StringInput) ApplicationSecurityGroupAssociationOutput

func (ApplicationSecurityGroupAssociationMapOutput) ToApplicationSecurityGroupAssociationMapOutput added in v5.31.0 

func (o ApplicationSecurityGroupAssociationMapOutput) ToApplicationSecurityGroupAssociationMapOutput() ApplicationSecurityGroupAssociationMapOutput

func (ApplicationSecurityGroupAssociationMapOutput) ToApplicationSecurityGroupAssociationMapOutputWithContext added in v5.31.0 

func (o ApplicationSecurityGroupAssociationMapOutput) ToApplicationSecurityGroupAssociationMapOutputWithContext(ctx context.Context) ApplicationSecurityGroupAssociationMapOutput

type ApplicationSecurityGroupAssociationOutput added in v5.31.0 

type ApplicationSecurityGroupAssociationOutput struct{ *pulumi.OutputState }

func (ApplicationSecurityGroupAssociationOutput) ApplicationSecurityGroupId added in v5.31.0 

func (o ApplicationSecurityGroupAssociationOutput) ApplicationSecurityGroupId() pulumi.StringOutput

The id of application security group to associate. Changing this forces a new resource to be created.

func (ApplicationSecurityGroupAssociationOutput) ElementType added in v5.31.0 

func (ApplicationSecurityGroupAssociationOutput) ElementType() reflect.Type

func (ApplicationSecurityGroupAssociationOutput) PrivateEndpointId added in v5.31.0 

func (o ApplicationSecurityGroupAssociationOutput) PrivateEndpointId() pulumi.StringOutput

The id of private endpoint to associate. Changing this forces a new resource to be created.

func (ApplicationSecurityGroupAssociationOutput) ToApplicationSecurityGroupAssociationOutput added in v5.31.0 

func (o ApplicationSecurityGroupAssociationOutput) ToApplicationSecurityGroupAssociationOutput() ApplicationSecurityGroupAssociationOutput

func (ApplicationSecurityGroupAssociationOutput) ToApplicationSecurityGroupAssociationOutputWithContext added in v5.31.0 

func (o ApplicationSecurityGroupAssociationOutput) ToApplicationSecurityGroupAssociationOutputWithContext(ctx context.Context) ApplicationSecurityGroupAssociationOutput

type ApplicationSecurityGroupAssociationState added in v5.31.0 

type ApplicationSecurityGroupAssociationState struct {
	// The id of application security group to associate. Changing this forces a new resource to be created.
	ApplicationSecurityGroupId pulumi.StringPtrInput
	// The id of private endpoint to associate. Changing this forces a new resource to be created.
	PrivateEndpointId pulumi.StringPtrInput
}

func (ApplicationSecurityGroupAssociationState) ElementType added in v5.31.0 

func (ApplicationSecurityGroupAssociationState) ElementType() reflect.Type

type Endpoint 

type Endpoint struct {
	pulumi.CustomResourceState

	// A `customDnsConfigs` block as defined below.
	CustomDnsConfigs EndpointCustomDnsConfigArrayOutput `pulumi:"customDnsConfigs"`
	// The custom name of the network interface attached to the private endpoint. Changing this forces a new resource to be created.
	CustomNetworkInterfaceName pulumi.StringPtrOutput `pulumi:"customNetworkInterfaceName"`
	// One or more `ipConfiguration` 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.
	IpConfigurations EndpointIpConfigurationArrayOutput `pulumi:"ipConfigurations"`
	// The supported Azure location where the resource exists. Changing this forces a new resource to be created.
	Location pulumi.StringOutput `pulumi:"location"`
	// Specifies the Name of the Private Endpoint. Changing this forces a new resource to be created.
	Name pulumi.StringOutput `pulumi:"name"`
	// A `networkInterface` block as defined below.
	NetworkInterfaces EndpointNetworkInterfaceArrayOutput `pulumi:"networkInterfaces"`
	// A `privateDnsZoneConfigs` block as defined below.
	PrivateDnsZoneConfigs EndpointPrivateDnsZoneConfigArrayOutput `pulumi:"privateDnsZoneConfigs"`
	// A `privateDnsZoneGroup` block as defined below.
	PrivateDnsZoneGroup EndpointPrivateDnsZoneGroupPtrOutput `pulumi:"privateDnsZoneGroup"`
	// A `privateServiceConnection` block as defined below.
	PrivateServiceConnection EndpointPrivateServiceConnectionOutput `pulumi:"privateServiceConnection"`
	// Specifies the Name of the Resource Group within which the Private Endpoint should exist. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringOutput `pulumi:"resourceGroupName"`
	// 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.
	SubnetId pulumi.StringOutput `pulumi:"subnetId"`
	// A mapping of tags to assign to the resource.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
}

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

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/lb"
"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/network"
"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/privatedns"
"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/privatelink"
"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-resources"),
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		exampleVirtualNetwork, err := network.NewVirtualNetwork(ctx, "example", &network.VirtualNetworkArgs{
			Name: pulumi.String("example-network"),
			AddressSpaces: pulumi.StringArray{
				pulumi.String("10.0.0.0/16"),
			},
			Location:          example.Location,
			ResourceGroupName: example.Name,
		})
		if err != nil {
			return err
		}
		service, err := network.NewSubnet(ctx, "service", &network.SubnetArgs{
			Name:               pulumi.String("service"),
			ResourceGroupName:  example.Name,
			VirtualNetworkName: exampleVirtualNetwork.Name,
			AddressPrefixes: pulumi.StringArray{
				pulumi.String("10.0.1.0/24"),
			},
			EnforcePrivateLinkServiceNetworkPolicies: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		endpoint, err := network.NewSubnet(ctx, "endpoint", &network.SubnetArgs{
			Name:               pulumi.String("endpoint"),
			ResourceGroupName:  example.Name,
			VirtualNetworkName: exampleVirtualNetwork.Name,
			AddressPrefixes: pulumi.StringArray{
				pulumi.String("10.0.2.0/24"),
			},
			EnforcePrivateLinkEndpointNetworkPolicies: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		examplePublicIp, err := network.NewPublicIp(ctx, "example", &network.PublicIpArgs{
			Name:              pulumi.String("example-pip"),
			Sku:               pulumi.String("Standard"),
			Location:          example.Location,
			ResourceGroupName: example.Name,
			AllocationMethod:  pulumi.String("Static"),
		})
		if err != nil {
			return err
		}
		exampleLoadBalancer, err := lb.NewLoadBalancer(ctx, "example", &lb.LoadBalancerArgs{
			Name:              pulumi.String("example-lb"),
			Sku:               pulumi.String("Standard"),
			Location:          example.Location,
			ResourceGroupName: example.Name,
			FrontendIpConfigurations: lb.LoadBalancerFrontendIpConfigurationArray{
				&lb.LoadBalancerFrontendIpConfigurationArgs{
					Name:              examplePublicIp.Name,
					PublicIpAddressId: examplePublicIp.ID(),
				},
			},
		})
		if err != nil {
			return err
		}
		exampleLinkService, err := privatedns.NewLinkService(ctx, "example", &privatedns.LinkServiceArgs{
			Name:              pulumi.String("example-privatelink"),
			Location:          example.Location,
			ResourceGroupName: example.Name,
			NatIpConfigurations: privatedns.LinkServiceNatIpConfigurationArray{
				&privatedns.LinkServiceNatIpConfigurationArgs{
					Name:     examplePublicIp.Name,
					Primary:  pulumi.Bool(true),
					SubnetId: service.ID(),
				},
			},
			LoadBalancerFrontendIpConfigurationIds: pulumi.StringArray{
				pulumi.String(exampleLoadBalancer.FrontendIpConfigurations.ApplyT(func(frontendIpConfigurations []lb.LoadBalancerFrontendIpConfiguration) (*string, error) {
					return &frontendIpConfigurations[0].Id, nil
				}).(pulumi.StringPtrOutput)),
			},
		})
		if err != nil {
			return err
		}
		_, err = privatelink.NewEndpoint(ctx, "example", &privatelink.EndpointArgs{
			Name:              pulumi.String("example-endpoint"),
			Location:          example.Location,
			ResourceGroupName: example.Name,
			SubnetId:          endpoint.ID(),
			PrivateServiceConnection: &privatelink.EndpointPrivateServiceConnectionArgs{
				Name:                        pulumi.String("example-privateserviceconnection"),
				PrivateConnectionResourceId: exampleLinkService.ID(),
				IsManualConnection:          pulumi.Bool(false),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

Using a Private Link Service Alias with existing resources:

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/network"
"github.com/pulumi/pulumi-azure/sdk/v5/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
	})
}

```

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

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/network"
"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/privatedns"
"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/privatelink"
"github.com/pulumi/pulumi-azure/sdk/v5/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
	})
}

```

## 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.

```sh $ pulumi import azure:privatelink/endpoint:Endpoint example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.Network/privateEndpoints/endpoint1 ```

func GetEndpoint 

func GetEndpoint(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *EndpointState, opts ...pulumi.ResourceOption) (*Endpoint, error)

GetEndpoint gets an existing Endpoint resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewEndpoint 

func NewEndpoint(ctx *pulumi.Context,
	name string, args *EndpointArgs, opts ...pulumi.ResourceOption) (*Endpoint, error)

NewEndpoint registers a new resource with the given unique name, arguments, and options.

func (*Endpoint) ElementType 

func (*Endpoint) ElementType() reflect.Type

func (*Endpoint) ToEndpointOutput 

func (i *Endpoint) ToEndpointOutput() EndpointOutput

func (*Endpoint) ToEndpointOutputWithContext 

func (i *Endpoint) ToEndpointOutputWithContext(ctx context.Context) EndpointOutput

type EndpointArgs 

type EndpointArgs struct {
	// The custom name of the network interface attached to the private endpoint. Changing this forces a new resource to be created.
	CustomNetworkInterfaceName pulumi.StringPtrInput
	// One or more `ipConfiguration` 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.
	IpConfigurations EndpointIpConfigurationArrayInput
	// The supported Azure location where the resource exists. Changing this forces a new resource to be created.
	Location pulumi.StringPtrInput
	// Specifies the Name of the Private Endpoint. Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// A `privateDnsZoneGroup` block as defined below.
	PrivateDnsZoneGroup EndpointPrivateDnsZoneGroupPtrInput
	// A `privateServiceConnection` block as defined below.
	PrivateServiceConnection EndpointPrivateServiceConnectionInput
	// Specifies the Name of the Resource Group within which the Private Endpoint should exist. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringInput
	// 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.
	SubnetId pulumi.StringInput
	// A mapping of tags to assign to the resource.
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a Endpoint resource.

func (EndpointArgs) ElementType 

func (EndpointArgs) ElementType() reflect.Type

type EndpointArray 

type EndpointArray []EndpointInput

func (EndpointArray) ElementType 

func (EndpointArray) ElementType() reflect.Type

func (EndpointArray) ToEndpointArrayOutput 

func (i EndpointArray) ToEndpointArrayOutput() EndpointArrayOutput

func (EndpointArray) ToEndpointArrayOutputWithContext 

func (i EndpointArray) ToEndpointArrayOutputWithContext(ctx context.Context) EndpointArrayOutput

type EndpointArrayInput 

type EndpointArrayInput interface {
	pulumi.Input

	ToEndpointArrayOutput() EndpointArrayOutput
	ToEndpointArrayOutputWithContext(context.Context) EndpointArrayOutput
}

EndpointArrayInput is an input type that accepts EndpointArray and EndpointArrayOutput values. You can construct a concrete instance of `EndpointArrayInput` via: 

EndpointArray{ EndpointArgs{...} }

type EndpointArrayOutput 

type EndpointArrayOutput struct{ *pulumi.OutputState }

func (EndpointArrayOutput) ElementType 

func (EndpointArrayOutput) ElementType() reflect.Type

func (EndpointArrayOutput) Index 

func (o EndpointArrayOutput) Index(i pulumi.IntInput) EndpointOutput

func (EndpointArrayOutput) ToEndpointArrayOutput 

func (o EndpointArrayOutput) ToEndpointArrayOutput() EndpointArrayOutput

func (EndpointArrayOutput) ToEndpointArrayOutputWithContext 

func (o EndpointArrayOutput) ToEndpointArrayOutputWithContext(ctx context.Context) EndpointArrayOutput

type EndpointCustomDnsConfig 

type EndpointCustomDnsConfig struct {
	// The fully qualified domain name to the `privateDnsZone`.
	Fqdn *string `pulumi:"fqdn"`
	// A list of all IP Addresses that map to the `privateDnsZone` fqdn.
	IpAddresses []string `pulumi:"ipAddresses"`
}

type EndpointCustomDnsConfigArgs 

type EndpointCustomDnsConfigArgs struct {
	// The fully qualified domain name to the `privateDnsZone`.
	Fqdn pulumi.StringPtrInput `pulumi:"fqdn"`
	// A list of all IP Addresses that map to the `privateDnsZone` fqdn.
	IpAddresses pulumi.StringArrayInput `pulumi:"ipAddresses"`
}

func (EndpointCustomDnsConfigArgs) ElementType 

func (EndpointCustomDnsConfigArgs) ElementType() reflect.Type

func (EndpointCustomDnsConfigArgs) ToEndpointCustomDnsConfigOutput 

func (i EndpointCustomDnsConfigArgs) ToEndpointCustomDnsConfigOutput() EndpointCustomDnsConfigOutput

func (EndpointCustomDnsConfigArgs) ToEndpointCustomDnsConfigOutputWithContext 

func (i EndpointCustomDnsConfigArgs) ToEndpointCustomDnsConfigOutputWithContext(ctx context.Context) EndpointCustomDnsConfigOutput

type EndpointCustomDnsConfigArray 

type EndpointCustomDnsConfigArray []EndpointCustomDnsConfigInput

func (EndpointCustomDnsConfigArray) ElementType 

func (EndpointCustomDnsConfigArray) ElementType() reflect.Type

func (EndpointCustomDnsConfigArray) ToEndpointCustomDnsConfigArrayOutput 

func (i EndpointCustomDnsConfigArray) ToEndpointCustomDnsConfigArrayOutput() EndpointCustomDnsConfigArrayOutput

func (EndpointCustomDnsConfigArray) ToEndpointCustomDnsConfigArrayOutputWithContext 

func (i EndpointCustomDnsConfigArray) ToEndpointCustomDnsConfigArrayOutputWithContext(ctx context.Context) EndpointCustomDnsConfigArrayOutput

type EndpointCustomDnsConfigArrayInput 

type EndpointCustomDnsConfigArrayInput interface {
	pulumi.Input

	ToEndpointCustomDnsConfigArrayOutput() EndpointCustomDnsConfigArrayOutput
	ToEndpointCustomDnsConfigArrayOutputWithContext(context.Context) EndpointCustomDnsConfigArrayOutput
}

EndpointCustomDnsConfigArrayInput is an input type that accepts EndpointCustomDnsConfigArray and EndpointCustomDnsConfigArrayOutput values. You can construct a concrete instance of `EndpointCustomDnsConfigArrayInput` via: 

EndpointCustomDnsConfigArray{ EndpointCustomDnsConfigArgs{...} }

type EndpointCustomDnsConfigArrayOutput 

type EndpointCustomDnsConfigArrayOutput struct{ *pulumi.OutputState }

func (EndpointCustomDnsConfigArrayOutput) ElementType 

func (EndpointCustomDnsConfigArrayOutput) ElementType() reflect.Type

func (EndpointCustomDnsConfigArrayOutput) Index 

func (o EndpointCustomDnsConfigArrayOutput) Index(i pulumi.IntInput) EndpointCustomDnsConfigOutput

func (EndpointCustomDnsConfigArrayOutput) ToEndpointCustomDnsConfigArrayOutput 

func (o EndpointCustomDnsConfigArrayOutput) ToEndpointCustomDnsConfigArrayOutput() EndpointCustomDnsConfigArrayOutput

func (EndpointCustomDnsConfigArrayOutput) ToEndpointCustomDnsConfigArrayOutputWithContext 

func (o EndpointCustomDnsConfigArrayOutput) ToEndpointCustomDnsConfigArrayOutputWithContext(ctx context.Context) EndpointCustomDnsConfigArrayOutput

type EndpointCustomDnsConfigInput 

type EndpointCustomDnsConfigInput interface {
	pulumi.Input

	ToEndpointCustomDnsConfigOutput() EndpointCustomDnsConfigOutput
	ToEndpointCustomDnsConfigOutputWithContext(context.Context) EndpointCustomDnsConfigOutput
}

EndpointCustomDnsConfigInput is an input type that accepts EndpointCustomDnsConfigArgs and EndpointCustomDnsConfigOutput values. You can construct a concrete instance of `EndpointCustomDnsConfigInput` via: 

EndpointCustomDnsConfigArgs{...}

type EndpointCustomDnsConfigOutput 

type EndpointCustomDnsConfigOutput struct{ *pulumi.OutputState }

func (EndpointCustomDnsConfigOutput) ElementType 

func (EndpointCustomDnsConfigOutput) ElementType() reflect.Type

func (EndpointCustomDnsConfigOutput) Fqdn 

func (o EndpointCustomDnsConfigOutput) Fqdn() pulumi.StringPtrOutput

The fully qualified domain name to the `privateDnsZone`.

func (EndpointCustomDnsConfigOutput) IpAddresses 

func (o EndpointCustomDnsConfigOutput) IpAddresses() pulumi.StringArrayOutput

A list of all IP Addresses that map to the `privateDnsZone` fqdn.

func (EndpointCustomDnsConfigOutput) ToEndpointCustomDnsConfigOutput 

func (o EndpointCustomDnsConfigOutput) ToEndpointCustomDnsConfigOutput() EndpointCustomDnsConfigOutput

func (EndpointCustomDnsConfigOutput) ToEndpointCustomDnsConfigOutputWithContext 

func (o EndpointCustomDnsConfigOutput) ToEndpointCustomDnsConfigOutputWithContext(ctx context.Context) EndpointCustomDnsConfigOutput

type EndpointInput 

type EndpointInput interface {
	pulumi.Input

	ToEndpointOutput() EndpointOutput
	ToEndpointOutputWithContext(ctx context.Context) EndpointOutput
}

type EndpointIpConfiguration added in v5.18.0 

type EndpointIpConfiguration struct {
	// Specifies the member name this IP address applies to. If it is not specified, it will use the value of `subresourceName`. Changing this forces a new resource to be created.
	//
	// > **NOTE:** `memberName` will be required and will not take the value of `subresourceName` in the next major version.
	MemberName *string `pulumi:"memberName"`
	// Specifies the Name of the IP Configuration. Changing this forces a new resource to be created.
	Name string `pulumi:"name"`
	// Specifies the static IP address within the private endpoint's subnet to be used. Changing this forces a new resource to be created.
	PrivateIpAddress string `pulumi:"privateIpAddress"`
	// Specifies the subresource this IP address applies to. `subresourceNames` corresponds to `groupId`. Changing this forces a new resource to be created.
	SubresourceName *string `pulumi:"subresourceName"`
}

type EndpointIpConfigurationArgs added in v5.18.0 

type EndpointIpConfigurationArgs struct {
	// Specifies the member name this IP address applies to. If it is not specified, it will use the value of `subresourceName`. Changing this forces a new resource to be created.
	//
	// > **NOTE:** `memberName` will be required and will not take the value of `subresourceName` in the next major version.
	MemberName pulumi.StringPtrInput `pulumi:"memberName"`
	// Specifies the Name of the IP Configuration. Changing this forces a new resource to be created.
	Name pulumi.StringInput `pulumi:"name"`
	// Specifies the static IP address within the private endpoint's subnet to be used. Changing this forces a new resource to be created.
	PrivateIpAddress pulumi.StringInput `pulumi:"privateIpAddress"`
	// Specifies the subresource this IP address applies to. `subresourceNames` corresponds to `groupId`. Changing this forces a new resource to be created.
	SubresourceName pulumi.StringPtrInput `pulumi:"subresourceName"`
}

func (EndpointIpConfigurationArgs) ElementType added in v5.18.0 

func (EndpointIpConfigurationArgs) ElementType() reflect.Type

func (EndpointIpConfigurationArgs) ToEndpointIpConfigurationOutput added in v5.18.0 

func (i EndpointIpConfigurationArgs) ToEndpointIpConfigurationOutput() EndpointIpConfigurationOutput

func (EndpointIpConfigurationArgs) ToEndpointIpConfigurationOutputWithContext added in v5.18.0 

func (i EndpointIpConfigurationArgs) ToEndpointIpConfigurationOutputWithContext(ctx context.Context) EndpointIpConfigurationOutput

type EndpointIpConfigurationArray added in v5.28.0 

type EndpointIpConfigurationArray []EndpointIpConfigurationInput

func (EndpointIpConfigurationArray) ElementType added in v5.28.0 

func (EndpointIpConfigurationArray) ElementType() reflect.Type

func (EndpointIpConfigurationArray) ToEndpointIpConfigurationArrayOutput added in v5.28.0 

func (i EndpointIpConfigurationArray) ToEndpointIpConfigurationArrayOutput() EndpointIpConfigurationArrayOutput

func (EndpointIpConfigurationArray) ToEndpointIpConfigurationArrayOutputWithContext added in v5.28.0 

func (i EndpointIpConfigurationArray) ToEndpointIpConfigurationArrayOutputWithContext(ctx context.Context) EndpointIpConfigurationArrayOutput

type EndpointIpConfigurationArrayInput added in v5.28.0 

type EndpointIpConfigurationArrayInput interface {
	pulumi.Input

	ToEndpointIpConfigurationArrayOutput() EndpointIpConfigurationArrayOutput
	ToEndpointIpConfigurationArrayOutputWithContext(context.Context) EndpointIpConfigurationArrayOutput
}

EndpointIpConfigurationArrayInput is an input type that accepts EndpointIpConfigurationArray and EndpointIpConfigurationArrayOutput values. You can construct a concrete instance of `EndpointIpConfigurationArrayInput` via: 

EndpointIpConfigurationArray{ EndpointIpConfigurationArgs{...} }

type EndpointIpConfigurationArrayOutput added in v5.28.0 

type EndpointIpConfigurationArrayOutput struct{ *pulumi.OutputState }

func (EndpointIpConfigurationArrayOutput) ElementType added in v5.28.0 

func (EndpointIpConfigurationArrayOutput) ElementType() reflect.Type

func (EndpointIpConfigurationArrayOutput) Index added in v5.28.0 

func (o EndpointIpConfigurationArrayOutput) Index(i pulumi.IntInput) EndpointIpConfigurationOutput

func (EndpointIpConfigurationArrayOutput) ToEndpointIpConfigurationArrayOutput added in v5.28.0 

func (o EndpointIpConfigurationArrayOutput) ToEndpointIpConfigurationArrayOutput() EndpointIpConfigurationArrayOutput

func (EndpointIpConfigurationArrayOutput) ToEndpointIpConfigurationArrayOutputWithContext added in v5.28.0 

func (o EndpointIpConfigurationArrayOutput) ToEndpointIpConfigurationArrayOutputWithContext(ctx context.Context) EndpointIpConfigurationArrayOutput

type EndpointIpConfigurationInput added in v5.18.0 

type EndpointIpConfigurationInput interface {
	pulumi.Input

	ToEndpointIpConfigurationOutput() EndpointIpConfigurationOutput
	ToEndpointIpConfigurationOutputWithContext(context.Context) EndpointIpConfigurationOutput
}

EndpointIpConfigurationInput is an input type that accepts EndpointIpConfigurationArgs and EndpointIpConfigurationOutput values. You can construct a concrete instance of `EndpointIpConfigurationInput` via: 

EndpointIpConfigurationArgs{...}

type EndpointIpConfigurationOutput added in v5.18.0 

type EndpointIpConfigurationOutput struct{ *pulumi.OutputState }

func (EndpointIpConfigurationOutput) ElementType added in v5.18.0 

func (EndpointIpConfigurationOutput) ElementType() reflect.Type

func (EndpointIpConfigurationOutput) MemberName added in v5.28.0 

func (o EndpointIpConfigurationOutput) MemberName() pulumi.StringPtrOutput

Specifies the member name this IP address applies to. If it is not specified, it will use the value of `subresourceName`. Changing this forces a new resource to be created.

> **NOTE:** `memberName` will be required and will not take the value of `subresourceName` in the next major version.

func (EndpointIpConfigurationOutput) Name added in v5.18.0 

func (o EndpointIpConfigurationOutput) Name() pulumi.StringOutput

Specifies the Name of the IP Configuration. Changing this forces a new resource to be created.

func (EndpointIpConfigurationOutput) PrivateIpAddress added in v5.18.0 

func (o EndpointIpConfigurationOutput) PrivateIpAddress() pulumi.StringOutput

Specifies the static IP address within the private endpoint's subnet to be used. Changing this forces a new resource to be created.

func (EndpointIpConfigurationOutput) SubresourceName added in v5.18.0 

func (o EndpointIpConfigurationOutput) SubresourceName() pulumi.StringPtrOutput

Specifies the subresource this IP address applies to. `subresourceNames` corresponds to `groupId`. Changing this forces a new resource to be created.

func (EndpointIpConfigurationOutput) ToEndpointIpConfigurationOutput added in v5.18.0 

func (o EndpointIpConfigurationOutput) ToEndpointIpConfigurationOutput() EndpointIpConfigurationOutput

func (EndpointIpConfigurationOutput) ToEndpointIpConfigurationOutputWithContext added in v5.18.0 

func (o EndpointIpConfigurationOutput) ToEndpointIpConfigurationOutputWithContext(ctx context.Context) EndpointIpConfigurationOutput

type EndpointMap 

type EndpointMap map[string]EndpointInput

func (EndpointMap) ElementType 

func (EndpointMap) ElementType() reflect.Type

func (EndpointMap) ToEndpointMapOutput 

func (i EndpointMap) ToEndpointMapOutput() EndpointMapOutput

func (EndpointMap) ToEndpointMapOutputWithContext 

func (i EndpointMap) ToEndpointMapOutputWithContext(ctx context.Context) EndpointMapOutput

type EndpointMapInput 

type EndpointMapInput interface {
	pulumi.Input

	ToEndpointMapOutput() EndpointMapOutput
	ToEndpointMapOutputWithContext(context.Context) EndpointMapOutput
}

EndpointMapInput is an input type that accepts EndpointMap and EndpointMapOutput values. You can construct a concrete instance of `EndpointMapInput` via: 

EndpointMap{ "key": EndpointArgs{...} }

type EndpointMapOutput 

type EndpointMapOutput struct{ *pulumi.OutputState }

func (EndpointMapOutput) ElementType 

func (EndpointMapOutput) ElementType() reflect.Type

func (EndpointMapOutput) MapIndex 

func (o EndpointMapOutput) MapIndex(k pulumi.StringInput) EndpointOutput

func (EndpointMapOutput) ToEndpointMapOutput 

func (o EndpointMapOutput) ToEndpointMapOutput() EndpointMapOutput

func (EndpointMapOutput) ToEndpointMapOutputWithContext 

func (o EndpointMapOutput) ToEndpointMapOutputWithContext(ctx context.Context) EndpointMapOutput

type EndpointNetworkInterface 

type EndpointNetworkInterface struct {
	// The ID of the Private DNS Zone Config.
	Id *string `pulumi:"id"`
	// Specifies the Name of the Private Endpoint. Changing this forces a new resource to be created.
	Name *string `pulumi:"name"`
}

type EndpointNetworkInterfaceArgs 

type EndpointNetworkInterfaceArgs struct {
	// The ID of the Private DNS Zone Config.
	Id pulumi.StringPtrInput `pulumi:"id"`
	// Specifies the Name of the Private Endpoint. Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput `pulumi:"name"`
}

func (EndpointNetworkInterfaceArgs) ElementType 

func (EndpointNetworkInterfaceArgs) ElementType() reflect.Type

func (EndpointNetworkInterfaceArgs) ToEndpointNetworkInterfaceOutput 

func (i EndpointNetworkInterfaceArgs) ToEndpointNetworkInterfaceOutput() EndpointNetworkInterfaceOutput

func (EndpointNetworkInterfaceArgs) ToEndpointNetworkInterfaceOutputWithContext 

func (i EndpointNetworkInterfaceArgs) ToEndpointNetworkInterfaceOutputWithContext(ctx context.Context) EndpointNetworkInterfaceOutput

type EndpointNetworkInterfaceArray 

type EndpointNetworkInterfaceArray []EndpointNetworkInterfaceInput

func (EndpointNetworkInterfaceArray) ElementType 

func (EndpointNetworkInterfaceArray) ElementType() reflect.Type

func (EndpointNetworkInterfaceArray) ToEndpointNetworkInterfaceArrayOutput 

func (i EndpointNetworkInterfaceArray) ToEndpointNetworkInterfaceArrayOutput() EndpointNetworkInterfaceArrayOutput

func (EndpointNetworkInterfaceArray) ToEndpointNetworkInterfaceArrayOutputWithContext 

func (i EndpointNetworkInterfaceArray) ToEndpointNetworkInterfaceArrayOutputWithContext(ctx context.Context) EndpointNetworkInterfaceArrayOutput

type EndpointNetworkInterfaceArrayInput 

type EndpointNetworkInterfaceArrayInput interface {
	pulumi.Input

	ToEndpointNetworkInterfaceArrayOutput() EndpointNetworkInterfaceArrayOutput
	ToEndpointNetworkInterfaceArrayOutputWithContext(context.Context) EndpointNetworkInterfaceArrayOutput
}

EndpointNetworkInterfaceArrayInput is an input type that accepts EndpointNetworkInterfaceArray and EndpointNetworkInterfaceArrayOutput values. You can construct a concrete instance of `EndpointNetworkInterfaceArrayInput` via: 

EndpointNetworkInterfaceArray{ EndpointNetworkInterfaceArgs{...} }

type EndpointNetworkInterfaceArrayOutput 

type EndpointNetworkInterfaceArrayOutput struct{ *pulumi.OutputState }

func (EndpointNetworkInterfaceArrayOutput) ElementType 

func (EndpointNetworkInterfaceArrayOutput) ElementType() reflect.Type

func (EndpointNetworkInterfaceArrayOutput) Index 

func (o EndpointNetworkInterfaceArrayOutput) Index(i pulumi.IntInput) EndpointNetworkInterfaceOutput

func (EndpointNetworkInterfaceArrayOutput) ToEndpointNetworkInterfaceArrayOutput 

func (o EndpointNetworkInterfaceArrayOutput) ToEndpointNetworkInterfaceArrayOutput() EndpointNetworkInterfaceArrayOutput

func (EndpointNetworkInterfaceArrayOutput) ToEndpointNetworkInterfaceArrayOutputWithContext 

func (o EndpointNetworkInterfaceArrayOutput) ToEndpointNetworkInterfaceArrayOutputWithContext(ctx context.Context) EndpointNetworkInterfaceArrayOutput

type EndpointNetworkInterfaceInput 

type EndpointNetworkInterfaceInput interface {
	pulumi.Input

	ToEndpointNetworkInterfaceOutput() EndpointNetworkInterfaceOutput
	ToEndpointNetworkInterfaceOutputWithContext(context.Context) EndpointNetworkInterfaceOutput
}

EndpointNetworkInterfaceInput is an input type that accepts EndpointNetworkInterfaceArgs and EndpointNetworkInterfaceOutput values. You can construct a concrete instance of `EndpointNetworkInterfaceInput` via: 

EndpointNetworkInterfaceArgs{...}

type EndpointNetworkInterfaceOutput 

type EndpointNetworkInterfaceOutput struct{ *pulumi.OutputState }

func (EndpointNetworkInterfaceOutput) ElementType 

func (EndpointNetworkInterfaceOutput) ElementType() reflect.Type

func (EndpointNetworkInterfaceOutput) Id 

func (o EndpointNetworkInterfaceOutput) Id() pulumi.StringPtrOutput

The ID of the Private DNS Zone Config.

func (EndpointNetworkInterfaceOutput) Name 

func (o EndpointNetworkInterfaceOutput) Name() pulumi.StringPtrOutput

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

func (EndpointNetworkInterfaceOutput) ToEndpointNetworkInterfaceOutput 

func (o EndpointNetworkInterfaceOutput) ToEndpointNetworkInterfaceOutput() EndpointNetworkInterfaceOutput

func (EndpointNetworkInterfaceOutput) ToEndpointNetworkInterfaceOutputWithContext 

func (o EndpointNetworkInterfaceOutput) ToEndpointNetworkInterfaceOutputWithContext(ctx context.Context) EndpointNetworkInterfaceOutput

type EndpointOutput 

type EndpointOutput struct{ *pulumi.OutputState }

func (EndpointOutput) CustomDnsConfigs added in v5.5.0 

func (o EndpointOutput) CustomDnsConfigs() EndpointCustomDnsConfigArrayOutput

A `customDnsConfigs` block as defined below.

func (EndpointOutput) CustomNetworkInterfaceName added in v5.21.0 

func (o EndpointOutput) CustomNetworkInterfaceName() pulumi.StringPtrOutput

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

func (EndpointOutput) ElementType 

func (EndpointOutput) ElementType() reflect.Type

func (EndpointOutput) IpConfigurations added in v5.28.0 

func (o EndpointOutput) IpConfigurations() EndpointIpConfigurationArrayOutput

One or more `ipConfiguration` 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.

func (EndpointOutput) Location added in v5.5.0 

func (o EndpointOutput) Location() pulumi.StringOutput

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

func (EndpointOutput) Name added in v5.5.0 

func (o EndpointOutput) Name() pulumi.StringOutput

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

func (EndpointOutput) NetworkInterfaces added in v5.5.0 

func (o EndpointOutput) NetworkInterfaces() EndpointNetworkInterfaceArrayOutput

A `networkInterface` block as defined below.

func (EndpointOutput) PrivateDnsZoneConfigs added in v5.5.0 

func (o EndpointOutput) PrivateDnsZoneConfigs() EndpointPrivateDnsZoneConfigArrayOutput

A `privateDnsZoneConfigs` block as defined below.

func (EndpointOutput) PrivateDnsZoneGroup added in v5.5.0 

func (o EndpointOutput) PrivateDnsZoneGroup() EndpointPrivateDnsZoneGroupPtrOutput

A `privateDnsZoneGroup` block as defined below.

func (EndpointOutput) PrivateServiceConnection added in v5.5.0 

func (o EndpointOutput) PrivateServiceConnection() EndpointPrivateServiceConnectionOutput

A `privateServiceConnection` block as defined below.

func (EndpointOutput) ResourceGroupName added in v5.5.0 

func (o EndpointOutput) ResourceGroupName() pulumi.StringOutput

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

func (EndpointOutput) SubnetId added in v5.5.0 

func (o EndpointOutput) SubnetId() pulumi.StringOutput

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.

func (EndpointOutput) Tags added in v5.5.0 

func (o EndpointOutput) Tags() pulumi.StringMapOutput

A mapping of tags to assign to the resource.

func (EndpointOutput) ToEndpointOutput 

func (o EndpointOutput) ToEndpointOutput() EndpointOutput

func (EndpointOutput) ToEndpointOutputWithContext 

func (o EndpointOutput) ToEndpointOutputWithContext(ctx context.Context) EndpointOutput

type EndpointPrivateDnsZoneConfig 

type EndpointPrivateDnsZoneConfig struct {
	// The ID of the Private DNS Zone Config.
	Id *string `pulumi:"id"`
	// Specifies the Name of the Private Endpoint. Changing this forces a new resource to be created.
	Name *string `pulumi:"name"`
	// A list of IP Addresses
	PrivateDnsZoneId *string `pulumi:"privateDnsZoneId"`
	// A `recordSets` block as defined below.
	RecordSets []EndpointPrivateDnsZoneConfigRecordSet `pulumi:"recordSets"`
}

type EndpointPrivateDnsZoneConfigArgs 

type EndpointPrivateDnsZoneConfigArgs struct {
	// The ID of the Private DNS Zone Config.
	Id pulumi.StringPtrInput `pulumi:"id"`
	// Specifies the Name of the Private Endpoint. Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput `pulumi:"name"`
	// A list of IP Addresses
	PrivateDnsZoneId pulumi.StringPtrInput `pulumi:"privateDnsZoneId"`
	// A `recordSets` block as defined below.
	RecordSets EndpointPrivateDnsZoneConfigRecordSetArrayInput `pulumi:"recordSets"`
}

func (EndpointPrivateDnsZoneConfigArgs) ElementType 

func (EndpointPrivateDnsZoneConfigArgs) ElementType() reflect.Type

func (EndpointPrivateDnsZoneConfigArgs) ToEndpointPrivateDnsZoneConfigOutput 

func (i EndpointPrivateDnsZoneConfigArgs) ToEndpointPrivateDnsZoneConfigOutput() EndpointPrivateDnsZoneConfigOutput

func (EndpointPrivateDnsZoneConfigArgs) ToEndpointPrivateDnsZoneConfigOutputWithContext 

func (i EndpointPrivateDnsZoneConfigArgs) ToEndpointPrivateDnsZoneConfigOutputWithContext(ctx context.Context) EndpointPrivateDnsZoneConfigOutput

type EndpointPrivateDnsZoneConfigArray 

type EndpointPrivateDnsZoneConfigArray []EndpointPrivateDnsZoneConfigInput

func (EndpointPrivateDnsZoneConfigArray) ElementType 

func (EndpointPrivateDnsZoneConfigArray) ElementType() reflect.Type

func (EndpointPrivateDnsZoneConfigArray) ToEndpointPrivateDnsZoneConfigArrayOutput 

func (i EndpointPrivateDnsZoneConfigArray) ToEndpointPrivateDnsZoneConfigArrayOutput() EndpointPrivateDnsZoneConfigArrayOutput

func (EndpointPrivateDnsZoneConfigArray) ToEndpointPrivateDnsZoneConfigArrayOutputWithContext 

func (i EndpointPrivateDnsZoneConfigArray) ToEndpointPrivateDnsZoneConfigArrayOutputWithContext(ctx context.Context) EndpointPrivateDnsZoneConfigArrayOutput

type EndpointPrivateDnsZoneConfigArrayInput 

type EndpointPrivateDnsZoneConfigArrayInput interface {
	pulumi.Input

	ToEndpointPrivateDnsZoneConfigArrayOutput() EndpointPrivateDnsZoneConfigArrayOutput
	ToEndpointPrivateDnsZoneConfigArrayOutputWithContext(context.Context) EndpointPrivateDnsZoneConfigArrayOutput
}

EndpointPrivateDnsZoneConfigArrayInput is an input type that accepts EndpointPrivateDnsZoneConfigArray and EndpointPrivateDnsZoneConfigArrayOutput values. You can construct a concrete instance of `EndpointPrivateDnsZoneConfigArrayInput` via: 

EndpointPrivateDnsZoneConfigArray{ EndpointPrivateDnsZoneConfigArgs{...} }

type EndpointPrivateDnsZoneConfigArrayOutput 

type EndpointPrivateDnsZoneConfigArrayOutput struct{ *pulumi.OutputState }

func (EndpointPrivateDnsZoneConfigArrayOutput) ElementType 

func (EndpointPrivateDnsZoneConfigArrayOutput) ElementType() reflect.Type

func (EndpointPrivateDnsZoneConfigArrayOutput) Index 

func (o EndpointPrivateDnsZoneConfigArrayOutput) Index(i pulumi.IntInput) EndpointPrivateDnsZoneConfigOutput

func (EndpointPrivateDnsZoneConfigArrayOutput) ToEndpointPrivateDnsZoneConfigArrayOutput 

func (o EndpointPrivateDnsZoneConfigArrayOutput) ToEndpointPrivateDnsZoneConfigArrayOutput() EndpointPrivateDnsZoneConfigArrayOutput

func (EndpointPrivateDnsZoneConfigArrayOutput) ToEndpointPrivateDnsZoneConfigArrayOutputWithContext 

func (o EndpointPrivateDnsZoneConfigArrayOutput) ToEndpointPrivateDnsZoneConfigArrayOutputWithContext(ctx context.Context) EndpointPrivateDnsZoneConfigArrayOutput

type EndpointPrivateDnsZoneConfigInput 

type EndpointPrivateDnsZoneConfigInput interface {
	pulumi.Input

	ToEndpointPrivateDnsZoneConfigOutput() EndpointPrivateDnsZoneConfigOutput
	ToEndpointPrivateDnsZoneConfigOutputWithContext(context.Context) EndpointPrivateDnsZoneConfigOutput
}

EndpointPrivateDnsZoneConfigInput is an input type that accepts EndpointPrivateDnsZoneConfigArgs and EndpointPrivateDnsZoneConfigOutput values. You can construct a concrete instance of `EndpointPrivateDnsZoneConfigInput` via: 

EndpointPrivateDnsZoneConfigArgs{...}

type EndpointPrivateDnsZoneConfigOutput 

type EndpointPrivateDnsZoneConfigOutput struct{ *pulumi.OutputState }

func (EndpointPrivateDnsZoneConfigOutput) ElementType 

func (EndpointPrivateDnsZoneConfigOutput) ElementType() reflect.Type

func (EndpointPrivateDnsZoneConfigOutput) Id 

func (o EndpointPrivateDnsZoneConfigOutput) Id() pulumi.StringPtrOutput

The ID of the Private DNS Zone Config.

func (EndpointPrivateDnsZoneConfigOutput) Name 

func (o EndpointPrivateDnsZoneConfigOutput) Name() pulumi.StringPtrOutput

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

func (EndpointPrivateDnsZoneConfigOutput) PrivateDnsZoneId 

func (o EndpointPrivateDnsZoneConfigOutput) PrivateDnsZoneId() pulumi.StringPtrOutput

A list of IP Addresses

func (EndpointPrivateDnsZoneConfigOutput) RecordSets 

func (o EndpointPrivateDnsZoneConfigOutput) RecordSets() EndpointPrivateDnsZoneConfigRecordSetArrayOutput

A `recordSets` block as defined below.

func (EndpointPrivateDnsZoneConfigOutput) ToEndpointPrivateDnsZoneConfigOutput 

func (o EndpointPrivateDnsZoneConfigOutput) ToEndpointPrivateDnsZoneConfigOutput() EndpointPrivateDnsZoneConfigOutput

func (EndpointPrivateDnsZoneConfigOutput) ToEndpointPrivateDnsZoneConfigOutputWithContext 

func (o EndpointPrivateDnsZoneConfigOutput) ToEndpointPrivateDnsZoneConfigOutputWithContext(ctx context.Context) EndpointPrivateDnsZoneConfigOutput

type EndpointPrivateDnsZoneConfigRecordSet 

type EndpointPrivateDnsZoneConfigRecordSet struct {
	// The fully qualified domain name to the `privateDnsZone`.
	Fqdn *string `pulumi:"fqdn"`
	// A list of all IP Addresses that map to the `privateDnsZone` fqdn.
	IpAddresses []string `pulumi:"ipAddresses"`
	// Specifies the Name of the Private Endpoint. Changing this forces a new resource to be created.
	Name *string `pulumi:"name"`
	// The time to live for each connection to the `privateDnsZone`.
	Ttl *int `pulumi:"ttl"`
	// The type of DNS record.
	Type *string `pulumi:"type"`
}

type EndpointPrivateDnsZoneConfigRecordSetArgs 

type EndpointPrivateDnsZoneConfigRecordSetArgs struct {
	// The fully qualified domain name to the `privateDnsZone`.
	Fqdn pulumi.StringPtrInput `pulumi:"fqdn"`
	// A list of all IP Addresses that map to the `privateDnsZone` fqdn.
	IpAddresses pulumi.StringArrayInput `pulumi:"ipAddresses"`
	// Specifies the Name of the Private Endpoint. Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput `pulumi:"name"`
	// The time to live for each connection to the `privateDnsZone`.
	Ttl pulumi.IntPtrInput `pulumi:"ttl"`
	// The type of DNS record.
	Type pulumi.StringPtrInput `pulumi:"type"`
}

func (EndpointPrivateDnsZoneConfigRecordSetArgs) ElementType 

func (EndpointPrivateDnsZoneConfigRecordSetArgs) ElementType() reflect.Type

func (EndpointPrivateDnsZoneConfigRecordSetArgs) ToEndpointPrivateDnsZoneConfigRecordSetOutput 

func (i EndpointPrivateDnsZoneConfigRecordSetArgs) ToEndpointPrivateDnsZoneConfigRecordSetOutput() EndpointPrivateDnsZoneConfigRecordSetOutput

func (EndpointPrivateDnsZoneConfigRecordSetArgs) ToEndpointPrivateDnsZoneConfigRecordSetOutputWithContext 

func (i EndpointPrivateDnsZoneConfigRecordSetArgs) ToEndpointPrivateDnsZoneConfigRecordSetOutputWithContext(ctx context.Context) EndpointPrivateDnsZoneConfigRecordSetOutput

type EndpointPrivateDnsZoneConfigRecordSetArray 

type EndpointPrivateDnsZoneConfigRecordSetArray []EndpointPrivateDnsZoneConfigRecordSetInput

func (EndpointPrivateDnsZoneConfigRecordSetArray) ElementType 

func (EndpointPrivateDnsZoneConfigRecordSetArray) ElementType() reflect.Type

func (EndpointPrivateDnsZoneConfigRecordSetArray) ToEndpointPrivateDnsZoneConfigRecordSetArrayOutput 

func (i EndpointPrivateDnsZoneConfigRecordSetArray) ToEndpointPrivateDnsZoneConfigRecordSetArrayOutput() EndpointPrivateDnsZoneConfigRecordSetArrayOutput

func (EndpointPrivateDnsZoneConfigRecordSetArray) ToEndpointPrivateDnsZoneConfigRecordSetArrayOutputWithContext 

func (i EndpointPrivateDnsZoneConfigRecordSetArray) ToEndpointPrivateDnsZoneConfigRecordSetArrayOutputWithContext(ctx context.Context) EndpointPrivateDnsZoneConfigRecordSetArrayOutput

type EndpointPrivateDnsZoneConfigRecordSetArrayInput 

type EndpointPrivateDnsZoneConfigRecordSetArrayInput interface {
	pulumi.Input

	ToEndpointPrivateDnsZoneConfigRecordSetArrayOutput() EndpointPrivateDnsZoneConfigRecordSetArrayOutput
	ToEndpointPrivateDnsZoneConfigRecordSetArrayOutputWithContext(context.Context) EndpointPrivateDnsZoneConfigRecordSetArrayOutput
}

EndpointPrivateDnsZoneConfigRecordSetArrayInput is an input type that accepts EndpointPrivateDnsZoneConfigRecordSetArray and EndpointPrivateDnsZoneConfigRecordSetArrayOutput values. You can construct a concrete instance of `EndpointPrivateDnsZoneConfigRecordSetArrayInput` via: 

EndpointPrivateDnsZoneConfigRecordSetArray{ EndpointPrivateDnsZoneConfigRecordSetArgs{...} }

type EndpointPrivateDnsZoneConfigRecordSetArrayOutput 

type EndpointPrivateDnsZoneConfigRecordSetArrayOutput struct{ *pulumi.OutputState }

func (EndpointPrivateDnsZoneConfigRecordSetArrayOutput) ElementType 

func (EndpointPrivateDnsZoneConfigRecordSetArrayOutput) ElementType() reflect.Type

func (EndpointPrivateDnsZoneConfigRecordSetArrayOutput) Index 

func (o EndpointPrivateDnsZoneConfigRecordSetArrayOutput) Index(i pulumi.IntInput) EndpointPrivateDnsZoneConfigRecordSetOutput

func (EndpointPrivateDnsZoneConfigRecordSetArrayOutput) ToEndpointPrivateDnsZoneConfigRecordSetArrayOutput 

func (o EndpointPrivateDnsZoneConfigRecordSetArrayOutput) ToEndpointPrivateDnsZoneConfigRecordSetArrayOutput() EndpointPrivateDnsZoneConfigRecordSetArrayOutput

func (EndpointPrivateDnsZoneConfigRecordSetArrayOutput) ToEndpointPrivateDnsZoneConfigRecordSetArrayOutputWithContext 

func (o EndpointPrivateDnsZoneConfigRecordSetArrayOutput) ToEndpointPrivateDnsZoneConfigRecordSetArrayOutputWithContext(ctx context.Context) EndpointPrivateDnsZoneConfigRecordSetArrayOutput

type EndpointPrivateDnsZoneConfigRecordSetInput 

type EndpointPrivateDnsZoneConfigRecordSetInput interface {
	pulumi.Input

	ToEndpointPrivateDnsZoneConfigRecordSetOutput() EndpointPrivateDnsZoneConfigRecordSetOutput
	ToEndpointPrivateDnsZoneConfigRecordSetOutputWithContext(context.Context) EndpointPrivateDnsZoneConfigRecordSetOutput
}

EndpointPrivateDnsZoneConfigRecordSetInput is an input type that accepts EndpointPrivateDnsZoneConfigRecordSetArgs and EndpointPrivateDnsZoneConfigRecordSetOutput values. You can construct a concrete instance of `EndpointPrivateDnsZoneConfigRecordSetInput` via: 

EndpointPrivateDnsZoneConfigRecordSetArgs{...}

type EndpointPrivateDnsZoneConfigRecordSetOutput 

type EndpointPrivateDnsZoneConfigRecordSetOutput struct{ *pulumi.OutputState }

func (EndpointPrivateDnsZoneConfigRecordSetOutput) ElementType 

func (EndpointPrivateDnsZoneConfigRecordSetOutput) ElementType() reflect.Type

func (EndpointPrivateDnsZoneConfigRecordSetOutput) Fqdn 

func (o EndpointPrivateDnsZoneConfigRecordSetOutput) Fqdn() pulumi.StringPtrOutput

The fully qualified domain name to the `privateDnsZone`.

func (EndpointPrivateDnsZoneConfigRecordSetOutput) IpAddresses 

func (o EndpointPrivateDnsZoneConfigRecordSetOutput) IpAddresses() pulumi.StringArrayOutput

A list of all IP Addresses that map to the `privateDnsZone` fqdn.

func (EndpointPrivateDnsZoneConfigRecordSetOutput) Name 

func (o EndpointPrivateDnsZoneConfigRecordSetOutput) Name() pulumi.StringPtrOutput

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

func (EndpointPrivateDnsZoneConfigRecordSetOutput) ToEndpointPrivateDnsZoneConfigRecordSetOutput 

func (o EndpointPrivateDnsZoneConfigRecordSetOutput) ToEndpointPrivateDnsZoneConfigRecordSetOutput() EndpointPrivateDnsZoneConfigRecordSetOutput

func (EndpointPrivateDnsZoneConfigRecordSetOutput) ToEndpointPrivateDnsZoneConfigRecordSetOutputWithContext 

func (o EndpointPrivateDnsZoneConfigRecordSetOutput) ToEndpointPrivateDnsZoneConfigRecordSetOutputWithContext(ctx context.Context) EndpointPrivateDnsZoneConfigRecordSetOutput

func (EndpointPrivateDnsZoneConfigRecordSetOutput) Ttl 

func (o EndpointPrivateDnsZoneConfigRecordSetOutput) Ttl() pulumi.IntPtrOutput

The time to live for each connection to the `privateDnsZone`.

func (EndpointPrivateDnsZoneConfigRecordSetOutput) Type 

func (o EndpointPrivateDnsZoneConfigRecordSetOutput) Type() pulumi.StringPtrOutput

The type of DNS record.

type EndpointPrivateDnsZoneGroup 

type EndpointPrivateDnsZoneGroup struct {
	// The ID of the Private DNS Zone Config.
	Id *string `pulumi:"id"`
	// Specifies the Name of the Private DNS Zone Group.
	Name string `pulumi:"name"`
	// Specifies the list of Private DNS Zones to include within the `privateDnsZoneGroup`.
	PrivateDnsZoneIds []string `pulumi:"privateDnsZoneIds"`
}

type EndpointPrivateDnsZoneGroupArgs 

type EndpointPrivateDnsZoneGroupArgs struct {
	// The ID of the Private DNS Zone Config.
	Id pulumi.StringPtrInput `pulumi:"id"`
	// Specifies the Name of the Private DNS Zone Group.
	Name pulumi.StringInput `pulumi:"name"`
	// Specifies the list of Private DNS Zones to include within the `privateDnsZoneGroup`.
	PrivateDnsZoneIds pulumi.StringArrayInput `pulumi:"privateDnsZoneIds"`
}

func (EndpointPrivateDnsZoneGroupArgs) ElementType 

func (EndpointPrivateDnsZoneGroupArgs) ElementType() reflect.Type

func (EndpointPrivateDnsZoneGroupArgs) ToEndpointPrivateDnsZoneGroupOutput 

func (i EndpointPrivateDnsZoneGroupArgs) ToEndpointPrivateDnsZoneGroupOutput() EndpointPrivateDnsZoneGroupOutput

func (EndpointPrivateDnsZoneGroupArgs) ToEndpointPrivateDnsZoneGroupOutputWithContext 

func (i EndpointPrivateDnsZoneGroupArgs) ToEndpointPrivateDnsZoneGroupOutputWithContext(ctx context.Context) EndpointPrivateDnsZoneGroupOutput

func (EndpointPrivateDnsZoneGroupArgs) ToEndpointPrivateDnsZoneGroupPtrOutput 

func (i EndpointPrivateDnsZoneGroupArgs) ToEndpointPrivateDnsZoneGroupPtrOutput() EndpointPrivateDnsZoneGroupPtrOutput

func (EndpointPrivateDnsZoneGroupArgs) ToEndpointPrivateDnsZoneGroupPtrOutputWithContext 

func (i EndpointPrivateDnsZoneGroupArgs) ToEndpointPrivateDnsZoneGroupPtrOutputWithContext(ctx context.Context) EndpointPrivateDnsZoneGroupPtrOutput

type EndpointPrivateDnsZoneGroupInput 

type EndpointPrivateDnsZoneGroupInput interface {
	pulumi.Input

	ToEndpointPrivateDnsZoneGroupOutput() EndpointPrivateDnsZoneGroupOutput
	ToEndpointPrivateDnsZoneGroupOutputWithContext(context.Context) EndpointPrivateDnsZoneGroupOutput
}

EndpointPrivateDnsZoneGroupInput is an input type that accepts EndpointPrivateDnsZoneGroupArgs and EndpointPrivateDnsZoneGroupOutput values. You can construct a concrete instance of `EndpointPrivateDnsZoneGroupInput` via: 

EndpointPrivateDnsZoneGroupArgs{...}

type EndpointPrivateDnsZoneGroupOutput 

type EndpointPrivateDnsZoneGroupOutput struct{ *pulumi.OutputState }

func (EndpointPrivateDnsZoneGroupOutput) ElementType 

func (EndpointPrivateDnsZoneGroupOutput) ElementType() reflect.Type

func (EndpointPrivateDnsZoneGroupOutput) Id 

func (o EndpointPrivateDnsZoneGroupOutput) Id() pulumi.StringPtrOutput

The ID of the Private DNS Zone Config.

func (EndpointPrivateDnsZoneGroupOutput) Name 

func (o EndpointPrivateDnsZoneGroupOutput) Name() pulumi.StringOutput

Specifies the Name of the Private DNS Zone Group.

func (EndpointPrivateDnsZoneGroupOutput) PrivateDnsZoneIds 

func (o EndpointPrivateDnsZoneGroupOutput) PrivateDnsZoneIds() pulumi.StringArrayOutput

Specifies the list of Private DNS Zones to include within the `privateDnsZoneGroup`.

func (EndpointPrivateDnsZoneGroupOutput) ToEndpointPrivateDnsZoneGroupOutput 

func (o EndpointPrivateDnsZoneGroupOutput) ToEndpointPrivateDnsZoneGroupOutput() EndpointPrivateDnsZoneGroupOutput

func (EndpointPrivateDnsZoneGroupOutput) ToEndpointPrivateDnsZoneGroupOutputWithContext 

func (o EndpointPrivateDnsZoneGroupOutput) ToEndpointPrivateDnsZoneGroupOutputWithContext(ctx context.Context) EndpointPrivateDnsZoneGroupOutput

func (EndpointPrivateDnsZoneGroupOutput) ToEndpointPrivateDnsZoneGroupPtrOutput 

func (o EndpointPrivateDnsZoneGroupOutput) ToEndpointPrivateDnsZoneGroupPtrOutput() EndpointPrivateDnsZoneGroupPtrOutput

func (EndpointPrivateDnsZoneGroupOutput) ToEndpointPrivateDnsZoneGroupPtrOutputWithContext 

func (o EndpointPrivateDnsZoneGroupOutput) ToEndpointPrivateDnsZoneGroupPtrOutputWithContext(ctx context.Context) EndpointPrivateDnsZoneGroupPtrOutput

type EndpointPrivateDnsZoneGroupPtrInput 

type EndpointPrivateDnsZoneGroupPtrInput interface {
	pulumi.Input

	ToEndpointPrivateDnsZoneGroupPtrOutput() EndpointPrivateDnsZoneGroupPtrOutput
	ToEndpointPrivateDnsZoneGroupPtrOutputWithContext(context.Context) EndpointPrivateDnsZoneGroupPtrOutput
}

EndpointPrivateDnsZoneGroupPtrInput is an input type that accepts EndpointPrivateDnsZoneGroupArgs, EndpointPrivateDnsZoneGroupPtr and EndpointPrivateDnsZoneGroupPtrOutput values. You can construct a concrete instance of `EndpointPrivateDnsZoneGroupPtrInput` via: 

        EndpointPrivateDnsZoneGroupArgs{...}

or:

        nil

func EndpointPrivateDnsZoneGroupPtr 

func EndpointPrivateDnsZoneGroupPtr(v *EndpointPrivateDnsZoneGroupArgs) EndpointPrivateDnsZoneGroupPtrInput

type EndpointPrivateDnsZoneGroupPtrOutput 

type EndpointPrivateDnsZoneGroupPtrOutput struct{ *pulumi.OutputState }

func (EndpointPrivateDnsZoneGroupPtrOutput) Elem 

func (o EndpointPrivateDnsZoneGroupPtrOutput) Elem() EndpointPrivateDnsZoneGroupOutput

func (EndpointPrivateDnsZoneGroupPtrOutput) ElementType 

func (EndpointPrivateDnsZoneGroupPtrOutput) ElementType() reflect.Type

func (EndpointPrivateDnsZoneGroupPtrOutput) Id 

func (o EndpointPrivateDnsZoneGroupPtrOutput) Id() pulumi.StringPtrOutput

The ID of the Private DNS Zone Config.

func (EndpointPrivateDnsZoneGroupPtrOutput) Name 

func (o EndpointPrivateDnsZoneGroupPtrOutput) Name() pulumi.StringPtrOutput

Specifies the Name of the Private DNS Zone Group.

func (EndpointPrivateDnsZoneGroupPtrOutput) PrivateDnsZoneIds 

func (o EndpointPrivateDnsZoneGroupPtrOutput) PrivateDnsZoneIds() pulumi.StringArrayOutput

Specifies the list of Private DNS Zones to include within the `privateDnsZoneGroup`.

func (EndpointPrivateDnsZoneGroupPtrOutput) ToEndpointPrivateDnsZoneGroupPtrOutput 

func (o EndpointPrivateDnsZoneGroupPtrOutput) ToEndpointPrivateDnsZoneGroupPtrOutput() EndpointPrivateDnsZoneGroupPtrOutput

func (EndpointPrivateDnsZoneGroupPtrOutput) ToEndpointPrivateDnsZoneGroupPtrOutputWithContext 

func (o EndpointPrivateDnsZoneGroupPtrOutput) ToEndpointPrivateDnsZoneGroupPtrOutputWithContext(ctx context.Context) EndpointPrivateDnsZoneGroupPtrOutput

type EndpointPrivateServiceConnection 

type EndpointPrivateServiceConnection struct {
	// Does the Private Endpoint require Manual Approval from the remote resource owner? Changing this forces a new resource to be created.
	//
	// > **NOTE:** If you are trying to connect the Private Endpoint to a remote resource without having the correct RBAC permissions on the remote resource set this value to `true`.
	IsManualConnection bool `pulumi:"isManualConnection"`
	// Specifies the Name of the Private Service Connection. Changing this forces a new resource to be created.
	Name string `pulumi:"name"`
	// The Service Alias of the Private Link Enabled Remote Resource which this Private Endpoint should be connected to. One of `privateConnectionResourceId` or `privateConnectionResourceAlias` must be specified. Changing this forces a new resource to be created.
	PrivateConnectionResourceAlias *string `pulumi:"privateConnectionResourceAlias"`
	// The ID of the Private Link Enabled Remote Resource which this Private Endpoint should be connected to. One of `privateConnectionResourceId` or `privateConnectionResourceAlias` must be specified. Changing this forces a new resource to be created. For a web app or function app slot, the parent web app should be used in this field instead of a reference to the slot itself.
	PrivateConnectionResourceId *string `pulumi:"privateConnectionResourceId"`
	// (Required) The static IP address set by this configuration. It is recommended to use the private IP address exported in the `privateServiceConnection` block to obtain the address associated with the private endpoint.
	PrivateIpAddress *string `pulumi:"privateIpAddress"`
	// A message passed to the owner of the remote resource when the private endpoint attempts to establish the connection to the remote resource. The provider allows a maximum request message length of `140` characters, however the request message maximum length is dependent on the service the private endpoint is connected to. Only valid if `isManualConnection` is set to `true`.
	//
	// > **NOTE:** When connected to an SQL resource the `requestMessage` maximum length is `128`.
	RequestMessage *string `pulumi:"requestMessage"`
	// A list of subresource names which the Private Endpoint is able to connect to. `subresourceNames` corresponds to `groupId`. Possible values are detailed in the product [documentation](https://docs.microsoft.com/azure/private-link/private-endpoint-overview#private-link-resource) in the `Subresources` column. Changing this forces a new resource to be created.
	//
	// > **NOTE:** Some resource types (such as Storage Account) only support 1 subresource per private endpoint.
	//
	// > **NOTE:** For most Private Links one or more `subresourceNames` will need to be specified, please see the linked documentation for details.
	SubresourceNames []string `pulumi:"subresourceNames"`
}

type EndpointPrivateServiceConnectionArgs 

type EndpointPrivateServiceConnectionArgs struct {
	// Does the Private Endpoint require Manual Approval from the remote resource owner? Changing this forces a new resource to be created.
	//
	// > **NOTE:** If you are trying to connect the Private Endpoint to a remote resource without having the correct RBAC permissions on the remote resource set this value to `true`.
	IsManualConnection pulumi.BoolInput `pulumi:"isManualConnection"`
	// Specifies the Name of the Private Service Connection. Changing this forces a new resource to be created.
	Name pulumi.StringInput `pulumi:"name"`
	// The Service Alias of the Private Link Enabled Remote Resource which this Private Endpoint should be connected to. One of `privateConnectionResourceId` or `privateConnectionResourceAlias` must be specified. Changing this forces a new resource to be created.
	PrivateConnectionResourceAlias pulumi.StringPtrInput `pulumi:"privateConnectionResourceAlias"`
	// The ID of the Private Link Enabled Remote Resource which this Private Endpoint should be connected to. One of `privateConnectionResourceId` or `privateConnectionResourceAlias` must be specified. Changing this forces a new resource to be created. For a web app or function app slot, the parent web app should be used in this field instead of a reference to the slot itself.
	PrivateConnectionResourceId pulumi.StringPtrInput `pulumi:"privateConnectionResourceId"`
	// (Required) The static IP address set by this configuration. It is recommended to use the private IP address exported in the `privateServiceConnection` block to obtain the address associated with the private endpoint.
	PrivateIpAddress pulumi.StringPtrInput `pulumi:"privateIpAddress"`
	// A message passed to the owner of the remote resource when the private endpoint attempts to establish the connection to the remote resource. The provider allows a maximum request message length of `140` characters, however the request message maximum length is dependent on the service the private endpoint is connected to. Only valid if `isManualConnection` is set to `true`.
	//
	// > **NOTE:** When connected to an SQL resource the `requestMessage` maximum length is `128`.
	RequestMessage pulumi.StringPtrInput `pulumi:"requestMessage"`
	// A list of subresource names which the Private Endpoint is able to connect to. `subresourceNames` corresponds to `groupId`. Possible values are detailed in the product [documentation](https://docs.microsoft.com/azure/private-link/private-endpoint-overview#private-link-resource) in the `Subresources` column. Changing this forces a new resource to be created.
	//
	// > **NOTE:** Some resource types (such as Storage Account) only support 1 subresource per private endpoint.
	//
	// > **NOTE:** For most Private Links one or more `subresourceNames` will need to be specified, please see the linked documentation for details.
	SubresourceNames pulumi.StringArrayInput `pulumi:"subresourceNames"`
}

func (EndpointPrivateServiceConnectionArgs) ElementType 

func (EndpointPrivateServiceConnectionArgs) ElementType() reflect.Type

func (EndpointPrivateServiceConnectionArgs) ToEndpointPrivateServiceConnectionOutput 

func (i EndpointPrivateServiceConnectionArgs) ToEndpointPrivateServiceConnectionOutput() EndpointPrivateServiceConnectionOutput

func (EndpointPrivateServiceConnectionArgs) ToEndpointPrivateServiceConnectionOutputWithContext 

func (i EndpointPrivateServiceConnectionArgs) ToEndpointPrivateServiceConnectionOutputWithContext(ctx context.Context) EndpointPrivateServiceConnectionOutput

func (EndpointPrivateServiceConnectionArgs) ToEndpointPrivateServiceConnectionPtrOutput 

func (i EndpointPrivateServiceConnectionArgs) ToEndpointPrivateServiceConnectionPtrOutput() EndpointPrivateServiceConnectionPtrOutput

func (EndpointPrivateServiceConnectionArgs) ToEndpointPrivateServiceConnectionPtrOutputWithContext 

func (i EndpointPrivateServiceConnectionArgs) ToEndpointPrivateServiceConnectionPtrOutputWithContext(ctx context.Context) EndpointPrivateServiceConnectionPtrOutput

type EndpointPrivateServiceConnectionInput 

type EndpointPrivateServiceConnectionInput interface {
	pulumi.Input

	ToEndpointPrivateServiceConnectionOutput() EndpointPrivateServiceConnectionOutput
	ToEndpointPrivateServiceConnectionOutputWithContext(context.Context) EndpointPrivateServiceConnectionOutput
}

EndpointPrivateServiceConnectionInput is an input type that accepts EndpointPrivateServiceConnectionArgs and EndpointPrivateServiceConnectionOutput values. You can construct a concrete instance of `EndpointPrivateServiceConnectionInput` via: 

EndpointPrivateServiceConnectionArgs{...}

type EndpointPrivateServiceConnectionOutput 

type EndpointPrivateServiceConnectionOutput struct{ *pulumi.OutputState }

func (EndpointPrivateServiceConnectionOutput) ElementType 

func (EndpointPrivateServiceConnectionOutput) ElementType() reflect.Type

func (EndpointPrivateServiceConnectionOutput) IsManualConnection 

func (o EndpointPrivateServiceConnectionOutput) IsManualConnection() pulumi.BoolOutput

Does the Private Endpoint require Manual Approval from the remote resource owner? Changing this forces a new resource to be created.

> **NOTE:** If you are trying to connect the Private Endpoint to a remote resource without having the correct RBAC permissions on the remote resource set this value to `true`.

func (EndpointPrivateServiceConnectionOutput) Name 

func (o EndpointPrivateServiceConnectionOutput) Name() pulumi.StringOutput

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

func (EndpointPrivateServiceConnectionOutput) PrivateConnectionResourceAlias 

func (o EndpointPrivateServiceConnectionOutput) PrivateConnectionResourceAlias() pulumi.StringPtrOutput

The Service Alias of the Private Link Enabled Remote Resource which this Private Endpoint should be connected to. One of `privateConnectionResourceId` or `privateConnectionResourceAlias` must be specified. Changing this forces a new resource to be created.

func (EndpointPrivateServiceConnectionOutput) PrivateConnectionResourceId 

func (o EndpointPrivateServiceConnectionOutput) PrivateConnectionResourceId() pulumi.StringPtrOutput

The ID of the Private Link Enabled Remote Resource which this Private Endpoint should be connected to. One of `privateConnectionResourceId` or `privateConnectionResourceAlias` must be specified. Changing this forces a new resource to be created. For a web app or function app slot, the parent web app should be used in this field instead of a reference to the slot itself.

func (EndpointPrivateServiceConnectionOutput) PrivateIpAddress 

func (o EndpointPrivateServiceConnectionOutput) PrivateIpAddress() pulumi.StringPtrOutput

(Required) The static IP address set by this configuration. It is recommended to use the private IP address exported in the `privateServiceConnection` block to obtain the address associated with the private endpoint.

func (EndpointPrivateServiceConnectionOutput) RequestMessage 

func (o EndpointPrivateServiceConnectionOutput) RequestMessage() pulumi.StringPtrOutput

A message passed to the owner of the remote resource when the private endpoint attempts to establish the connection to the remote resource. The provider allows a maximum request message length of `140` characters, however the request message maximum length is dependent on the service the private endpoint is connected to. Only valid if `isManualConnection` is set to `true`.

> **NOTE:** When connected to an SQL resource the `requestMessage` maximum length is `128`.

func (EndpointPrivateServiceConnectionOutput) SubresourceNames 

func (o EndpointPrivateServiceConnectionOutput) SubresourceNames() pulumi.StringArrayOutput

A list of subresource names which the Private Endpoint is able to connect to. `subresourceNames` corresponds to `groupId`. Possible values are detailed in the product [documentation](https://docs.microsoft.com/azure/private-link/private-endpoint-overview#private-link-resource) in the `Subresources` column. Changing this forces a new resource to be created.

> **NOTE:** Some resource types (such as Storage Account) only support 1 subresource per private endpoint.

> **NOTE:** For most Private Links one or more `subresourceNames` will need to be specified, please see the linked documentation for details.

func (EndpointPrivateServiceConnectionOutput) ToEndpointPrivateServiceConnectionOutput 

func (o EndpointPrivateServiceConnectionOutput) ToEndpointPrivateServiceConnectionOutput() EndpointPrivateServiceConnectionOutput

func (EndpointPrivateServiceConnectionOutput) ToEndpointPrivateServiceConnectionOutputWithContext 

func (o EndpointPrivateServiceConnectionOutput) ToEndpointPrivateServiceConnectionOutputWithContext(ctx context.Context) EndpointPrivateServiceConnectionOutput

func (EndpointPrivateServiceConnectionOutput) ToEndpointPrivateServiceConnectionPtrOutput 

func (o EndpointPrivateServiceConnectionOutput) ToEndpointPrivateServiceConnectionPtrOutput() EndpointPrivateServiceConnectionPtrOutput

func (EndpointPrivateServiceConnectionOutput) ToEndpointPrivateServiceConnectionPtrOutputWithContext 

func (o EndpointPrivateServiceConnectionOutput) ToEndpointPrivateServiceConnectionPtrOutputWithContext(ctx context.Context) EndpointPrivateServiceConnectionPtrOutput

type EndpointPrivateServiceConnectionPtrInput 

type EndpointPrivateServiceConnectionPtrInput interface {
	pulumi.Input

	ToEndpointPrivateServiceConnectionPtrOutput() EndpointPrivateServiceConnectionPtrOutput
	ToEndpointPrivateServiceConnectionPtrOutputWithContext(context.Context) EndpointPrivateServiceConnectionPtrOutput
}

EndpointPrivateServiceConnectionPtrInput is an input type that accepts EndpointPrivateServiceConnectionArgs, EndpointPrivateServiceConnectionPtr and EndpointPrivateServiceConnectionPtrOutput values. You can construct a concrete instance of `EndpointPrivateServiceConnectionPtrInput` via: 

        EndpointPrivateServiceConnectionArgs{...}

or:

        nil

func EndpointPrivateServiceConnectionPtr 

func EndpointPrivateServiceConnectionPtr(v *EndpointPrivateServiceConnectionArgs) EndpointPrivateServiceConnectionPtrInput

type EndpointPrivateServiceConnectionPtrOutput 

type EndpointPrivateServiceConnectionPtrOutput struct{ *pulumi.OutputState }

func (EndpointPrivateServiceConnectionPtrOutput) Elem 

func (o EndpointPrivateServiceConnectionPtrOutput) Elem() EndpointPrivateServiceConnectionOutput

func (EndpointPrivateServiceConnectionPtrOutput) ElementType 

func (EndpointPrivateServiceConnectionPtrOutput) ElementType() reflect.Type

func (EndpointPrivateServiceConnectionPtrOutput) IsManualConnection 

func (o EndpointPrivateServiceConnectionPtrOutput) IsManualConnection() pulumi.BoolPtrOutput

Does the Private Endpoint require Manual Approval from the remote resource owner? Changing this forces a new resource to be created.

> **NOTE:** If you are trying to connect the Private Endpoint to a remote resource without having the correct RBAC permissions on the remote resource set this value to `true`.

func (EndpointPrivateServiceConnectionPtrOutput) Name 

func (o EndpointPrivateServiceConnectionPtrOutput) Name() pulumi.StringPtrOutput

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

func (EndpointPrivateServiceConnectionPtrOutput) PrivateConnectionResourceAlias 

func (o EndpointPrivateServiceConnectionPtrOutput) PrivateConnectionResourceAlias() pulumi.StringPtrOutput

The Service Alias of the Private Link Enabled Remote Resource which this Private Endpoint should be connected to. One of `privateConnectionResourceId` or `privateConnectionResourceAlias` must be specified. Changing this forces a new resource to be created.

func (EndpointPrivateServiceConnectionPtrOutput) PrivateConnectionResourceId 

func (o EndpointPrivateServiceConnectionPtrOutput) PrivateConnectionResourceId() pulumi.StringPtrOutput

The ID of the Private Link Enabled Remote Resource which this Private Endpoint should be connected to. One of `privateConnectionResourceId` or `privateConnectionResourceAlias` must be specified. Changing this forces a new resource to be created. For a web app or function app slot, the parent web app should be used in this field instead of a reference to the slot itself.

func (EndpointPrivateServiceConnectionPtrOutput) PrivateIpAddress 

func (o EndpointPrivateServiceConnectionPtrOutput) PrivateIpAddress() pulumi.StringPtrOutput

(Required) The static IP address set by this configuration. It is recommended to use the private IP address exported in the `privateServiceConnection` block to obtain the address associated with the private endpoint.

func (EndpointPrivateServiceConnectionPtrOutput) RequestMessage 

func (o EndpointPrivateServiceConnectionPtrOutput) RequestMessage() pulumi.StringPtrOutput

A message passed to the owner of the remote resource when the private endpoint attempts to establish the connection to the remote resource. The provider allows a maximum request message length of `140` characters, however the request message maximum length is dependent on the service the private endpoint is connected to. Only valid if `isManualConnection` is set to `true`.

> **NOTE:** When connected to an SQL resource the `requestMessage` maximum length is `128`.

func (EndpointPrivateServiceConnectionPtrOutput) SubresourceNames 

func (o EndpointPrivateServiceConnectionPtrOutput) SubresourceNames() pulumi.StringArrayOutput

A list of subresource names which the Private Endpoint is able to connect to. `subresourceNames` corresponds to `groupId`. Possible values are detailed in the product [documentation](https://docs.microsoft.com/azure/private-link/private-endpoint-overview#private-link-resource) in the `Subresources` column. Changing this forces a new resource to be created.

> **NOTE:** Some resource types (such as Storage Account) only support 1 subresource per private endpoint.

> **NOTE:** For most Private Links one or more `subresourceNames` will need to be specified, please see the linked documentation for details.

func (EndpointPrivateServiceConnectionPtrOutput) ToEndpointPrivateServiceConnectionPtrOutput 

func (o EndpointPrivateServiceConnectionPtrOutput) ToEndpointPrivateServiceConnectionPtrOutput() EndpointPrivateServiceConnectionPtrOutput

func (EndpointPrivateServiceConnectionPtrOutput) ToEndpointPrivateServiceConnectionPtrOutputWithContext 

func (o EndpointPrivateServiceConnectionPtrOutput) ToEndpointPrivateServiceConnectionPtrOutputWithContext(ctx context.Context) EndpointPrivateServiceConnectionPtrOutput

type EndpointState 

type EndpointState struct {
	// A `customDnsConfigs` block as defined below.
	CustomDnsConfigs EndpointCustomDnsConfigArrayInput
	// The custom name of the network interface attached to the private endpoint. Changing this forces a new resource to be created.
	CustomNetworkInterfaceName pulumi.StringPtrInput
	// One or more `ipConfiguration` 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.
	IpConfigurations EndpointIpConfigurationArrayInput
	// The supported Azure location where the resource exists. Changing this forces a new resource to be created.
	Location pulumi.StringPtrInput
	// Specifies the Name of the Private Endpoint. Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// A `networkInterface` block as defined below.
	NetworkInterfaces EndpointNetworkInterfaceArrayInput
	// A `privateDnsZoneConfigs` block as defined below.
	PrivateDnsZoneConfigs EndpointPrivateDnsZoneConfigArrayInput
	// A `privateDnsZoneGroup` block as defined below.
	PrivateDnsZoneGroup EndpointPrivateDnsZoneGroupPtrInput
	// A `privateServiceConnection` block as defined below.
	PrivateServiceConnection EndpointPrivateServiceConnectionPtrInput
	// Specifies the Name of the Resource Group within which the Private Endpoint should exist. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringPtrInput
	// 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.
	SubnetId pulumi.StringPtrInput
	// A mapping of tags to assign to the resource.
	Tags pulumi.StringMapInput
}

func (EndpointState) ElementType 

func (EndpointState) ElementType() reflect.Type

type GetEndpointConnectionArgs 

type GetEndpointConnectionArgs struct {
	// Specifies the Name of the private endpoint.
	Name string `pulumi:"name"`
	// Specifies the Name of the Resource Group within which the private endpoint exists.
	ResourceGroupName string `pulumi:"resourceGroupName"`
}

A collection of arguments for invoking getEndpointConnection.

type GetEndpointConnectionNetworkInterface 

type GetEndpointConnectionNetworkInterface struct {
	// The ID of the network interface associated with the private endpoint.
	Id string `pulumi:"id"`
	// Specifies the Name of the private endpoint.
	Name string `pulumi:"name"`
}

type GetEndpointConnectionNetworkInterfaceArgs 

type GetEndpointConnectionNetworkInterfaceArgs struct {
	// The ID of the network interface associated with the private endpoint.
	Id pulumi.StringInput `pulumi:"id"`
	// Specifies the Name of the private endpoint.
	Name pulumi.StringInput `pulumi:"name"`
}

func (GetEndpointConnectionNetworkInterfaceArgs) ElementType 

func (GetEndpointConnectionNetworkInterfaceArgs) ElementType() reflect.Type

func (GetEndpointConnectionNetworkInterfaceArgs) ToGetEndpointConnectionNetworkInterfaceOutput 

func (i GetEndpointConnectionNetworkInterfaceArgs) ToGetEndpointConnectionNetworkInterfaceOutput() GetEndpointConnectionNetworkInterfaceOutput

func (GetEndpointConnectionNetworkInterfaceArgs) ToGetEndpointConnectionNetworkInterfaceOutputWithContext 

func (i GetEndpointConnectionNetworkInterfaceArgs) ToGetEndpointConnectionNetworkInterfaceOutputWithContext(ctx context.Context) GetEndpointConnectionNetworkInterfaceOutput

type GetEndpointConnectionNetworkInterfaceArray 

type GetEndpointConnectionNetworkInterfaceArray []GetEndpointConnectionNetworkInterfaceInput

func (GetEndpointConnectionNetworkInterfaceArray) ElementType 

func (GetEndpointConnectionNetworkInterfaceArray) ElementType() reflect.Type

func (GetEndpointConnectionNetworkInterfaceArray) ToGetEndpointConnectionNetworkInterfaceArrayOutput 

func (i GetEndpointConnectionNetworkInterfaceArray) ToGetEndpointConnectionNetworkInterfaceArrayOutput() GetEndpointConnectionNetworkInterfaceArrayOutput

func (GetEndpointConnectionNetworkInterfaceArray) ToGetEndpointConnectionNetworkInterfaceArrayOutputWithContext 

func (i GetEndpointConnectionNetworkInterfaceArray) ToGetEndpointConnectionNetworkInterfaceArrayOutputWithContext(ctx context.Context) GetEndpointConnectionNetworkInterfaceArrayOutput

type GetEndpointConnectionNetworkInterfaceArrayInput 

type GetEndpointConnectionNetworkInterfaceArrayInput interface {
	pulumi.Input

	ToGetEndpointConnectionNetworkInterfaceArrayOutput() GetEndpointConnectionNetworkInterfaceArrayOutput
	ToGetEndpointConnectionNetworkInterfaceArrayOutputWithContext(context.Context) GetEndpointConnectionNetworkInterfaceArrayOutput
}

GetEndpointConnectionNetworkInterfaceArrayInput is an input type that accepts GetEndpointConnectionNetworkInterfaceArray and GetEndpointConnectionNetworkInterfaceArrayOutput values. You can construct a concrete instance of `GetEndpointConnectionNetworkInterfaceArrayInput` via: 

GetEndpointConnectionNetworkInterfaceArray{ GetEndpointConnectionNetworkInterfaceArgs{...} }

type GetEndpointConnectionNetworkInterfaceArrayOutput 

type GetEndpointConnectionNetworkInterfaceArrayOutput struct{ *pulumi.OutputState }

func (GetEndpointConnectionNetworkInterfaceArrayOutput) ElementType 

func (GetEndpointConnectionNetworkInterfaceArrayOutput) ElementType() reflect.Type

func (GetEndpointConnectionNetworkInterfaceArrayOutput) Index 

func (o GetEndpointConnectionNetworkInterfaceArrayOutput) Index(i pulumi.IntInput) GetEndpointConnectionNetworkInterfaceOutput

func (GetEndpointConnectionNetworkInterfaceArrayOutput) ToGetEndpointConnectionNetworkInterfaceArrayOutput 

func (o GetEndpointConnectionNetworkInterfaceArrayOutput) ToGetEndpointConnectionNetworkInterfaceArrayOutput() GetEndpointConnectionNetworkInterfaceArrayOutput

func (GetEndpointConnectionNetworkInterfaceArrayOutput) ToGetEndpointConnectionNetworkInterfaceArrayOutputWithContext 

func (o GetEndpointConnectionNetworkInterfaceArrayOutput) ToGetEndpointConnectionNetworkInterfaceArrayOutputWithContext(ctx context.Context) GetEndpointConnectionNetworkInterfaceArrayOutput

type GetEndpointConnectionNetworkInterfaceInput 

type GetEndpointConnectionNetworkInterfaceInput interface {
	pulumi.Input

	ToGetEndpointConnectionNetworkInterfaceOutput() GetEndpointConnectionNetworkInterfaceOutput
	ToGetEndpointConnectionNetworkInterfaceOutputWithContext(context.Context) GetEndpointConnectionNetworkInterfaceOutput
}

GetEndpointConnectionNetworkInterfaceInput is an input type that accepts GetEndpointConnectionNetworkInterfaceArgs and GetEndpointConnectionNetworkInterfaceOutput values. You can construct a concrete instance of `GetEndpointConnectionNetworkInterfaceInput` via: 

GetEndpointConnectionNetworkInterfaceArgs{...}

type GetEndpointConnectionNetworkInterfaceOutput 

type GetEndpointConnectionNetworkInterfaceOutput struct{ *pulumi.OutputState }

func (GetEndpointConnectionNetworkInterfaceOutput) ElementType 

func (GetEndpointConnectionNetworkInterfaceOutput) ElementType() reflect.Type

func (GetEndpointConnectionNetworkInterfaceOutput) Id 

func (o GetEndpointConnectionNetworkInterfaceOutput) Id() pulumi.StringOutput

The ID of the network interface associated with the private endpoint.

func (GetEndpointConnectionNetworkInterfaceOutput) Name 

func (o GetEndpointConnectionNetworkInterfaceOutput) Name() pulumi.StringOutput

Specifies the Name of the private endpoint.

func (GetEndpointConnectionNetworkInterfaceOutput) ToGetEndpointConnectionNetworkInterfaceOutput 

func (o GetEndpointConnectionNetworkInterfaceOutput) ToGetEndpointConnectionNetworkInterfaceOutput() GetEndpointConnectionNetworkInterfaceOutput

func (GetEndpointConnectionNetworkInterfaceOutput) ToGetEndpointConnectionNetworkInterfaceOutputWithContext 

func (o GetEndpointConnectionNetworkInterfaceOutput) ToGetEndpointConnectionNetworkInterfaceOutputWithContext(ctx context.Context) GetEndpointConnectionNetworkInterfaceOutput

type GetEndpointConnectionOutputArgs 

type GetEndpointConnectionOutputArgs struct {
	// Specifies the Name of the private endpoint.
	Name pulumi.StringInput `pulumi:"name"`
	// Specifies the Name of the Resource Group within which the private endpoint exists.
	ResourceGroupName pulumi.StringInput `pulumi:"resourceGroupName"`
}

A collection of arguments for invoking getEndpointConnection.

func (GetEndpointConnectionOutputArgs) ElementType 

func (GetEndpointConnectionOutputArgs) ElementType() reflect.Type

type GetEndpointConnectionPrivateServiceConnection 

type GetEndpointConnectionPrivateServiceConnection struct {
	// Specifies the Name of the private endpoint.
	Name string `pulumi:"name"`
	// The private IP address associated with the private endpoint, note that you will have a private IP address assigned to the private endpoint even if the connection request was `Rejected`.
	PrivateIpAddress string `pulumi:"privateIpAddress"`
	// Possible values are as follows:
	// Value | Meaning
	// -- | --
	// `Auto-Approved` | The remote resource owner has added you to the `Auto-Approved` RBAC permission list for the remote resource, all private endpoint connection requests will be automatically `Approved`.
	// `Deleted state` | The resource owner has `Rejected` the private endpoint connection request and has removed your private endpoint request from the remote resource.
	// `request/response message` | If you submitted a manual private endpoint connection request, while in the `Pending` status the `requestResponse` will display the same text from your `requestMessage` in the `privateServiceConnection` block above. If the private endpoint connection request was `Rejected` by the owner of the remote resource, the text for the rejection will be displayed as the `requestResponse` text, if the private endpoint connection request was `Approved` by the owner of the remote resource, the text for the approval will be displayed as the `requestResponse` text
	RequestResponse string `pulumi:"requestResponse"`
	// The current status of the private endpoint request, possible values will be `Pending`, `Approved`, `Rejected`, or `Disconnected`.
	Status string `pulumi:"status"`
}

type GetEndpointConnectionPrivateServiceConnectionArgs 

type GetEndpointConnectionPrivateServiceConnectionArgs struct {
	// Specifies the Name of the private endpoint.
	Name pulumi.StringInput `pulumi:"name"`
	// The private IP address associated with the private endpoint, note that you will have a private IP address assigned to the private endpoint even if the connection request was `Rejected`.
	PrivateIpAddress pulumi.StringInput `pulumi:"privateIpAddress"`
	// Possible values are as follows:
	// Value | Meaning
	// -- | --
	// `Auto-Approved` | The remote resource owner has added you to the `Auto-Approved` RBAC permission list for the remote resource, all private endpoint connection requests will be automatically `Approved`.
	// `Deleted state` | The resource owner has `Rejected` the private endpoint connection request and has removed your private endpoint request from the remote resource.
	// `request/response message` | If you submitted a manual private endpoint connection request, while in the `Pending` status the `requestResponse` will display the same text from your `requestMessage` in the `privateServiceConnection` block above. If the private endpoint connection request was `Rejected` by the owner of the remote resource, the text for the rejection will be displayed as the `requestResponse` text, if the private endpoint connection request was `Approved` by the owner of the remote resource, the text for the approval will be displayed as the `requestResponse` text
	RequestResponse pulumi.StringInput `pulumi:"requestResponse"`
	// The current status of the private endpoint request, possible values will be `Pending`, `Approved`, `Rejected`, or `Disconnected`.
	Status pulumi.StringInput `pulumi:"status"`
}

func (GetEndpointConnectionPrivateServiceConnectionArgs) ElementType 

func (GetEndpointConnectionPrivateServiceConnectionArgs) ElementType() reflect.Type

func (GetEndpointConnectionPrivateServiceConnectionArgs) ToGetEndpointConnectionPrivateServiceConnectionOutput 

func (i GetEndpointConnectionPrivateServiceConnectionArgs) ToGetEndpointConnectionPrivateServiceConnectionOutput() GetEndpointConnectionPrivateServiceConnectionOutput

func (GetEndpointConnectionPrivateServiceConnectionArgs) ToGetEndpointConnectionPrivateServiceConnectionOutputWithContext 

func (i GetEndpointConnectionPrivateServiceConnectionArgs) ToGetEndpointConnectionPrivateServiceConnectionOutputWithContext(ctx context.Context) GetEndpointConnectionPrivateServiceConnectionOutput

type GetEndpointConnectionPrivateServiceConnectionArray 

type GetEndpointConnectionPrivateServiceConnectionArray []GetEndpointConnectionPrivateServiceConnectionInput

func (GetEndpointConnectionPrivateServiceConnectionArray) ElementType 

func (GetEndpointConnectionPrivateServiceConnectionArray) ElementType() reflect.Type

func (GetEndpointConnectionPrivateServiceConnectionArray) ToGetEndpointConnectionPrivateServiceConnectionArrayOutput 

func (i GetEndpointConnectionPrivateServiceConnectionArray) ToGetEndpointConnectionPrivateServiceConnectionArrayOutput() GetEndpointConnectionPrivateServiceConnectionArrayOutput

func (GetEndpointConnectionPrivateServiceConnectionArray) ToGetEndpointConnectionPrivateServiceConnectionArrayOutputWithContext 

func (i GetEndpointConnectionPrivateServiceConnectionArray) ToGetEndpointConnectionPrivateServiceConnectionArrayOutputWithContext(ctx context.Context) GetEndpointConnectionPrivateServiceConnectionArrayOutput

type GetEndpointConnectionPrivateServiceConnectionArrayInput 

type GetEndpointConnectionPrivateServiceConnectionArrayInput interface {
	pulumi.Input

	ToGetEndpointConnectionPrivateServiceConnectionArrayOutput() GetEndpointConnectionPrivateServiceConnectionArrayOutput
	ToGetEndpointConnectionPrivateServiceConnectionArrayOutputWithContext(context.Context) GetEndpointConnectionPrivateServiceConnectionArrayOutput
}

GetEndpointConnectionPrivateServiceConnectionArrayInput is an input type that accepts GetEndpointConnectionPrivateServiceConnectionArray and GetEndpointConnectionPrivateServiceConnectionArrayOutput values. You can construct a concrete instance of `GetEndpointConnectionPrivateServiceConnectionArrayInput` via: 

GetEndpointConnectionPrivateServiceConnectionArray{ GetEndpointConnectionPrivateServiceConnectionArgs{...} }

type GetEndpointConnectionPrivateServiceConnectionArrayOutput 

type GetEndpointConnectionPrivateServiceConnectionArrayOutput struct{ *pulumi.OutputState }

func (GetEndpointConnectionPrivateServiceConnectionArrayOutput) ElementType 

func (GetEndpointConnectionPrivateServiceConnectionArrayOutput) ElementType() reflect.Type

func (GetEndpointConnectionPrivateServiceConnectionArrayOutput) Index 

func (o GetEndpointConnectionPrivateServiceConnectionArrayOutput) Index(i pulumi.IntInput) GetEndpointConnectionPrivateServiceConnectionOutput

func (GetEndpointConnectionPrivateServiceConnectionArrayOutput) ToGetEndpointConnectionPrivateServiceConnectionArrayOutput 

func (o GetEndpointConnectionPrivateServiceConnectionArrayOutput) ToGetEndpointConnectionPrivateServiceConnectionArrayOutput() GetEndpointConnectionPrivateServiceConnectionArrayOutput

func (GetEndpointConnectionPrivateServiceConnectionArrayOutput) ToGetEndpointConnectionPrivateServiceConnectionArrayOutputWithContext 

func (o GetEndpointConnectionPrivateServiceConnectionArrayOutput) ToGetEndpointConnectionPrivateServiceConnectionArrayOutputWithContext(ctx context.Context) GetEndpointConnectionPrivateServiceConnectionArrayOutput

type GetEndpointConnectionPrivateServiceConnectionInput 

type GetEndpointConnectionPrivateServiceConnectionInput interface {
	pulumi.Input

	ToGetEndpointConnectionPrivateServiceConnectionOutput() GetEndpointConnectionPrivateServiceConnectionOutput
	ToGetEndpointConnectionPrivateServiceConnectionOutputWithContext(context.Context) GetEndpointConnectionPrivateServiceConnectionOutput
}

GetEndpointConnectionPrivateServiceConnectionInput is an input type that accepts GetEndpointConnectionPrivateServiceConnectionArgs and GetEndpointConnectionPrivateServiceConnectionOutput values. You can construct a concrete instance of `GetEndpointConnectionPrivateServiceConnectionInput` via: 

GetEndpointConnectionPrivateServiceConnectionArgs{...}

type GetEndpointConnectionPrivateServiceConnectionOutput 

type GetEndpointConnectionPrivateServiceConnectionOutput struct{ *pulumi.OutputState }

func (GetEndpointConnectionPrivateServiceConnectionOutput) ElementType 

func (GetEndpointConnectionPrivateServiceConnectionOutput) ElementType() reflect.Type

func (GetEndpointConnectionPrivateServiceConnectionOutput) Name 

func (o GetEndpointConnectionPrivateServiceConnectionOutput) Name() pulumi.StringOutput

Specifies the Name of the private endpoint.

func (GetEndpointConnectionPrivateServiceConnectionOutput) PrivateIpAddress 

func (o GetEndpointConnectionPrivateServiceConnectionOutput) PrivateIpAddress() pulumi.StringOutput

The private IP address associated with the private endpoint, note that you will have a private IP address assigned to the private endpoint even if the connection request was `Rejected`.

func (GetEndpointConnectionPrivateServiceConnectionOutput) RequestResponse 

func (o GetEndpointConnectionPrivateServiceConnectionOutput) RequestResponse() pulumi.StringOutput

Possible values are as follows: Value | Meaning -- | -- `Auto-Approved` | The remote resource owner has added you to the `Auto-Approved` RBAC permission list for the remote resource, all private endpoint connection requests will be automatically `Approved`. `Deleted state` | The resource owner has `Rejected` the private endpoint connection request and has removed your private endpoint request from the remote resource. `request/response message` | If you submitted a manual private endpoint connection request, while in the `Pending` status the `requestResponse` will display the same text from your `requestMessage` in the `privateServiceConnection` block above. If the private endpoint connection request was `Rejected` by the owner of the remote resource, the text for the rejection will be displayed as the `requestResponse` text, if the private endpoint connection request was `Approved` by the owner of the remote resource, the text for the approval will be displayed as the `requestResponse` text

func (GetEndpointConnectionPrivateServiceConnectionOutput) Status 

func (o GetEndpointConnectionPrivateServiceConnectionOutput) Status() pulumi.StringOutput

The current status of the private endpoint request, possible values will be `Pending`, `Approved`, `Rejected`, or `Disconnected`.

func (GetEndpointConnectionPrivateServiceConnectionOutput) ToGetEndpointConnectionPrivateServiceConnectionOutput 

func (o GetEndpointConnectionPrivateServiceConnectionOutput) ToGetEndpointConnectionPrivateServiceConnectionOutput() GetEndpointConnectionPrivateServiceConnectionOutput

func (GetEndpointConnectionPrivateServiceConnectionOutput) ToGetEndpointConnectionPrivateServiceConnectionOutputWithContext 

func (o GetEndpointConnectionPrivateServiceConnectionOutput) ToGetEndpointConnectionPrivateServiceConnectionOutputWithContext(ctx context.Context) GetEndpointConnectionPrivateServiceConnectionOutput

type GetEndpointConnectionResult 

type GetEndpointConnectionResult struct {
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// The supported Azure location where the resource exists.
	Location string `pulumi:"location"`
	// The name of the private endpoint.
	Name                      string                                          `pulumi:"name"`
	NetworkInterfaces         []GetEndpointConnectionNetworkInterface         `pulumi:"networkInterfaces"`
	PrivateServiceConnections []GetEndpointConnectionPrivateServiceConnection `pulumi:"privateServiceConnections"`
	ResourceGroupName         string                                          `pulumi:"resourceGroupName"`
}

A collection of values returned by getEndpointConnection.

func GetEndpointConnection 

func GetEndpointConnection(ctx *pulumi.Context, args *GetEndpointConnectionArgs, opts ...pulumi.InvokeOption) (*GetEndpointConnectionResult, error)

Use this data source to access the connection status information about an existing Private Endpoint Connection.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/privatelink"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := privatelink.GetEndpointConnection(ctx, &privatelink.GetEndpointConnectionArgs{
			Name:              "example-private-endpoint",
			ResourceGroupName: "example-rg",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("privateEndpointStatus", example.PrivateServiceConnections[0].Status)
		return nil
	})
}

```

type GetEndpointConnectionResultOutput 

type GetEndpointConnectionResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getEndpointConnection.

func GetEndpointConnectionOutput 

func GetEndpointConnectionOutput(ctx *pulumi.Context, args GetEndpointConnectionOutputArgs, opts ...pulumi.InvokeOption) GetEndpointConnectionResultOutput

func (GetEndpointConnectionResultOutput) ElementType 

func (GetEndpointConnectionResultOutput) ElementType() reflect.Type

func (GetEndpointConnectionResultOutput) Id 

func (o GetEndpointConnectionResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (GetEndpointConnectionResultOutput) Location 

func (o GetEndpointConnectionResultOutput) Location() pulumi.StringOutput

The supported Azure location where the resource exists.

func (GetEndpointConnectionResultOutput) Name 

func (o GetEndpointConnectionResultOutput) Name() pulumi.StringOutput

The name of the private endpoint.

func (GetEndpointConnectionResultOutput) NetworkInterfaces 

func (o GetEndpointConnectionResultOutput) NetworkInterfaces() GetEndpointConnectionNetworkInterfaceArrayOutput

func (GetEndpointConnectionResultOutput) PrivateServiceConnections 

func (o GetEndpointConnectionResultOutput) PrivateServiceConnections() GetEndpointConnectionPrivateServiceConnectionArrayOutput

func (GetEndpointConnectionResultOutput) ResourceGroupName 

func (o GetEndpointConnectionResultOutput) ResourceGroupName() pulumi.StringOutput

func (GetEndpointConnectionResultOutput) ToGetEndpointConnectionResultOutput 

func (o GetEndpointConnectionResultOutput) ToGetEndpointConnectionResultOutput() GetEndpointConnectionResultOutput

func (GetEndpointConnectionResultOutput) ToGetEndpointConnectionResultOutputWithContext 

func (o GetEndpointConnectionResultOutput) ToGetEndpointConnectionResultOutputWithContext(ctx context.Context) GetEndpointConnectionResultOutput

type GetServiceArgs 

type GetServiceArgs struct {
	// The name of the private link service.
	Name string `pulumi:"name"`
	// The name of the resource group in which the private link service resides.
	ResourceGroupName string `pulumi:"resourceGroupName"`
}

A collection of arguments for invoking getService.

type GetServiceEndpointConnectionsArgs 

type GetServiceEndpointConnectionsArgs struct {
	// The name of the resource group in which the private link service resides.
	ResourceGroupName string `pulumi:"resourceGroupName"`
	// The resource ID of the private link service.
	ServiceId string `pulumi:"serviceId"`
}

A collection of arguments for invoking getServiceEndpointConnections.

type GetServiceEndpointConnectionsOutputArgs 

type GetServiceEndpointConnectionsOutputArgs struct {
	// The name of the resource group in which the private link service resides.
	ResourceGroupName pulumi.StringInput `pulumi:"resourceGroupName"`
	// The resource ID of the private link service.
	ServiceId pulumi.StringInput `pulumi:"serviceId"`
}

A collection of arguments for invoking getServiceEndpointConnections.

func (GetServiceEndpointConnectionsOutputArgs) ElementType 

func (GetServiceEndpointConnectionsOutputArgs) ElementType() reflect.Type

type GetServiceEndpointConnectionsPrivateEndpointConnection 

type GetServiceEndpointConnectionsPrivateEndpointConnection struct {
	// A message indicating if changes on the service provider require any updates or not.
	ActionRequired string `pulumi:"actionRequired"`
	// The resource id of the private link service connection between the private link service and the private link endpoint.
	ConnectionId string `pulumi:"connectionId"`
	// The name of the connection between the private link service and the private link endpoint.
	ConnectionName string `pulumi:"connectionName"`
	// The request for approval message or the reason for rejection message.
	Description string `pulumi:"description"`
	// The resource id of the private link endpoint.
	PrivateEndpointId string `pulumi:"privateEndpointId"`
	// The name of the private link endpoint.
	PrivateEndpointName string `pulumi:"privateEndpointName"`
	// Indicates the state of the connection between the private link service and the private link endpoint, possible values are `Pending`, `Approved` or `Rejected`.
	Status string `pulumi:"status"`
}

type GetServiceEndpointConnectionsPrivateEndpointConnectionArgs 

type GetServiceEndpointConnectionsPrivateEndpointConnectionArgs struct {
	// A message indicating if changes on the service provider require any updates or not.
	ActionRequired pulumi.StringInput `pulumi:"actionRequired"`
	// The resource id of the private link service connection between the private link service and the private link endpoint.
	ConnectionId pulumi.StringInput `pulumi:"connectionId"`
	// The name of the connection between the private link service and the private link endpoint.
	ConnectionName pulumi.StringInput `pulumi:"connectionName"`
	// The request for approval message or the reason for rejection message.
	Description pulumi.StringInput `pulumi:"description"`
	// The resource id of the private link endpoint.
	PrivateEndpointId pulumi.StringInput `pulumi:"privateEndpointId"`
	// The name of the private link endpoint.
	PrivateEndpointName pulumi.StringInput `pulumi:"privateEndpointName"`
	// Indicates the state of the connection between the private link service and the private link endpoint, possible values are `Pending`, `Approved` or `Rejected`.
	Status pulumi.StringInput `pulumi:"status"`
}

func (GetServiceEndpointConnectionsPrivateEndpointConnectionArgs) ElementType 

func (GetServiceEndpointConnectionsPrivateEndpointConnectionArgs) ElementType() reflect.Type

func (GetServiceEndpointConnectionsPrivateEndpointConnectionArgs) ToGetServiceEndpointConnectionsPrivateEndpointConnectionOutput 

func (i GetServiceEndpointConnectionsPrivateEndpointConnectionArgs) ToGetServiceEndpointConnectionsPrivateEndpointConnectionOutput() GetServiceEndpointConnectionsPrivateEndpointConnectionOutput

func (GetServiceEndpointConnectionsPrivateEndpointConnectionArgs) ToGetServiceEndpointConnectionsPrivateEndpointConnectionOutputWithContext 

func (i GetServiceEndpointConnectionsPrivateEndpointConnectionArgs) ToGetServiceEndpointConnectionsPrivateEndpointConnectionOutputWithContext(ctx context.Context) GetServiceEndpointConnectionsPrivateEndpointConnectionOutput

type GetServiceEndpointConnectionsPrivateEndpointConnectionArray 

type GetServiceEndpointConnectionsPrivateEndpointConnectionArray []GetServiceEndpointConnectionsPrivateEndpointConnectionInput

func (GetServiceEndpointConnectionsPrivateEndpointConnectionArray) ElementType 

func (GetServiceEndpointConnectionsPrivateEndpointConnectionArray) ElementType() reflect.Type

func (GetServiceEndpointConnectionsPrivateEndpointConnectionArray) ToGetServiceEndpointConnectionsPrivateEndpointConnectionArrayOutput 

func (i GetServiceEndpointConnectionsPrivateEndpointConnectionArray) ToGetServiceEndpointConnectionsPrivateEndpointConnectionArrayOutput() GetServiceEndpointConnectionsPrivateEndpointConnectionArrayOutput

func (GetServiceEndpointConnectionsPrivateEndpointConnectionArray) ToGetServiceEndpointConnectionsPrivateEndpointConnectionArrayOutputWithContext 

func (i GetServiceEndpointConnectionsPrivateEndpointConnectionArray) ToGetServiceEndpointConnectionsPrivateEndpointConnectionArrayOutputWithContext(ctx context.Context) GetServiceEndpointConnectionsPrivateEndpointConnectionArrayOutput

type GetServiceEndpointConnectionsPrivateEndpointConnectionArrayInput 

type GetServiceEndpointConnectionsPrivateEndpointConnectionArrayInput interface {
	pulumi.Input

	ToGetServiceEndpointConnectionsPrivateEndpointConnectionArrayOutput() GetServiceEndpointConnectionsPrivateEndpointConnectionArrayOutput
	ToGetServiceEndpointConnectionsPrivateEndpointConnectionArrayOutputWithContext(context.Context) GetServiceEndpointConnectionsPrivateEndpointConnectionArrayOutput
}

GetServiceEndpointConnectionsPrivateEndpointConnectionArrayInput is an input type that accepts GetServiceEndpointConnectionsPrivateEndpointConnectionArray and GetServiceEndpointConnectionsPrivateEndpointConnectionArrayOutput values. You can construct a concrete instance of `GetServiceEndpointConnectionsPrivateEndpointConnectionArrayInput` via: 

GetServiceEndpointConnectionsPrivateEndpointConnectionArray{ GetServiceEndpointConnectionsPrivateEndpointConnectionArgs{...} }

type GetServiceEndpointConnectionsPrivateEndpointConnectionArrayOutput 

type GetServiceEndpointConnectionsPrivateEndpointConnectionArrayOutput struct{ *pulumi.OutputState }

func (GetServiceEndpointConnectionsPrivateEndpointConnectionArrayOutput) ElementType 

func (GetServiceEndpointConnectionsPrivateEndpointConnectionArrayOutput) ElementType() reflect.Type

func (GetServiceEndpointConnectionsPrivateEndpointConnectionArrayOutput) Index 

func (o GetServiceEndpointConnectionsPrivateEndpointConnectionArrayOutput) Index(i pulumi.IntInput) GetServiceEndpointConnectionsPrivateEndpointConnectionOutput

func (GetServiceEndpointConnectionsPrivateEndpointConnectionArrayOutput) ToGetServiceEndpointConnectionsPrivateEndpointConnectionArrayOutput 

func (o GetServiceEndpointConnectionsPrivateEndpointConnectionArrayOutput) ToGetServiceEndpointConnectionsPrivateEndpointConnectionArrayOutput() GetServiceEndpointConnectionsPrivateEndpointConnectionArrayOutput

func (GetServiceEndpointConnectionsPrivateEndpointConnectionArrayOutput) ToGetServiceEndpointConnectionsPrivateEndpointConnectionArrayOutputWithContext 

func (o GetServiceEndpointConnectionsPrivateEndpointConnectionArrayOutput) ToGetServiceEndpointConnectionsPrivateEndpointConnectionArrayOutputWithContext(ctx context.Context) GetServiceEndpointConnectionsPrivateEndpointConnectionArrayOutput

type GetServiceEndpointConnectionsPrivateEndpointConnectionInput 

type GetServiceEndpointConnectionsPrivateEndpointConnectionInput interface {
	pulumi.Input

	ToGetServiceEndpointConnectionsPrivateEndpointConnectionOutput() GetServiceEndpointConnectionsPrivateEndpointConnectionOutput
	ToGetServiceEndpointConnectionsPrivateEndpointConnectionOutputWithContext(context.Context) GetServiceEndpointConnectionsPrivateEndpointConnectionOutput
}

GetServiceEndpointConnectionsPrivateEndpointConnectionInput is an input type that accepts GetServiceEndpointConnectionsPrivateEndpointConnectionArgs and GetServiceEndpointConnectionsPrivateEndpointConnectionOutput values. You can construct a concrete instance of `GetServiceEndpointConnectionsPrivateEndpointConnectionInput` via: 

GetServiceEndpointConnectionsPrivateEndpointConnectionArgs{...}

type GetServiceEndpointConnectionsPrivateEndpointConnectionOutput 

type GetServiceEndpointConnectionsPrivateEndpointConnectionOutput struct{ *pulumi.OutputState }

func (GetServiceEndpointConnectionsPrivateEndpointConnectionOutput) ActionRequired 

func (o GetServiceEndpointConnectionsPrivateEndpointConnectionOutput) ActionRequired() pulumi.StringOutput

A message indicating if changes on the service provider require any updates or not.

func (GetServiceEndpointConnectionsPrivateEndpointConnectionOutput) ConnectionId 

func (o GetServiceEndpointConnectionsPrivateEndpointConnectionOutput) ConnectionId() pulumi.StringOutput

The resource id of the private link service connection between the private link service and the private link endpoint.

func (GetServiceEndpointConnectionsPrivateEndpointConnectionOutput) ConnectionName 

func (o GetServiceEndpointConnectionsPrivateEndpointConnectionOutput) ConnectionName() pulumi.StringOutput

The name of the connection between the private link service and the private link endpoint.

func (GetServiceEndpointConnectionsPrivateEndpointConnectionOutput) Description 

func (o GetServiceEndpointConnectionsPrivateEndpointConnectionOutput) Description() pulumi.StringOutput

The request for approval message or the reason for rejection message.

func (GetServiceEndpointConnectionsPrivateEndpointConnectionOutput) ElementType 

func (GetServiceEndpointConnectionsPrivateEndpointConnectionOutput) ElementType() reflect.Type

func (GetServiceEndpointConnectionsPrivateEndpointConnectionOutput) PrivateEndpointId 

func (o GetServiceEndpointConnectionsPrivateEndpointConnectionOutput) PrivateEndpointId() pulumi.StringOutput

The resource id of the private link endpoint.

func (GetServiceEndpointConnectionsPrivateEndpointConnectionOutput) PrivateEndpointName 

func (o GetServiceEndpointConnectionsPrivateEndpointConnectionOutput) PrivateEndpointName() pulumi.StringOutput

The name of the private link endpoint.

func (GetServiceEndpointConnectionsPrivateEndpointConnectionOutput) Status 

func (o GetServiceEndpointConnectionsPrivateEndpointConnectionOutput) Status() pulumi.StringOutput

Indicates the state of the connection between the private link service and the private link endpoint, possible values are `Pending`, `Approved` or `Rejected`.

func (GetServiceEndpointConnectionsPrivateEndpointConnectionOutput) ToGetServiceEndpointConnectionsPrivateEndpointConnectionOutput 

func (o GetServiceEndpointConnectionsPrivateEndpointConnectionOutput) ToGetServiceEndpointConnectionsPrivateEndpointConnectionOutput() GetServiceEndpointConnectionsPrivateEndpointConnectionOutput

func (GetServiceEndpointConnectionsPrivateEndpointConnectionOutput) ToGetServiceEndpointConnectionsPrivateEndpointConnectionOutputWithContext 

func (o GetServiceEndpointConnectionsPrivateEndpointConnectionOutput) ToGetServiceEndpointConnectionsPrivateEndpointConnectionOutputWithContext(ctx context.Context) GetServiceEndpointConnectionsPrivateEndpointConnectionOutput

type GetServiceEndpointConnectionsResult 

type GetServiceEndpointConnectionsResult struct {
	// The provider-assigned unique ID for this managed resource.
	Id                         string                                                   `pulumi:"id"`
	Location                   string                                                   `pulumi:"location"`
	PrivateEndpointConnections []GetServiceEndpointConnectionsPrivateEndpointConnection `pulumi:"privateEndpointConnections"`
	ResourceGroupName          string                                                   `pulumi:"resourceGroupName"`
	ServiceId                  string                                                   `pulumi:"serviceId"`
	// The name of the private link service.
	ServiceName string `pulumi:"serviceName"`
}

A collection of values returned by getServiceEndpointConnections.

func GetServiceEndpointConnections 

func GetServiceEndpointConnections(ctx *pulumi.Context, args *GetServiceEndpointConnectionsArgs, opts ...pulumi.InvokeOption) (*GetServiceEndpointConnectionsResult, error)

Use this data source to access endpoint connection information about an existing Private Link Service.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/privatelink"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := privatelink.GetServiceEndpointConnections(ctx, &privatelink.GetServiceEndpointConnectionsArgs{
			ServiceId:         exampleAzurermPrivateLinkService.Id,
			ResourceGroupName: exampleAzurermResourceGroup.Name,
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("privateEndpointStatus", example.PrivateEndpointConnections[0].Status)
		return nil
	})
}

```

type GetServiceEndpointConnectionsResultOutput 

type GetServiceEndpointConnectionsResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getServiceEndpointConnections.

func GetServiceEndpointConnectionsOutput 

func GetServiceEndpointConnectionsOutput(ctx *pulumi.Context, args GetServiceEndpointConnectionsOutputArgs, opts ...pulumi.InvokeOption) GetServiceEndpointConnectionsResultOutput

func (GetServiceEndpointConnectionsResultOutput) ElementType 

func (GetServiceEndpointConnectionsResultOutput) ElementType() reflect.Type

func (GetServiceEndpointConnectionsResultOutput) Id 

func (o GetServiceEndpointConnectionsResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (GetServiceEndpointConnectionsResultOutput) Location 

func (o GetServiceEndpointConnectionsResultOutput) Location() pulumi.StringOutput

func (GetServiceEndpointConnectionsResultOutput) PrivateEndpointConnections 

func (o GetServiceEndpointConnectionsResultOutput) PrivateEndpointConnections() GetServiceEndpointConnectionsPrivateEndpointConnectionArrayOutput

func (GetServiceEndpointConnectionsResultOutput) ResourceGroupName 

func (o GetServiceEndpointConnectionsResultOutput) ResourceGroupName() pulumi.StringOutput

func (GetServiceEndpointConnectionsResultOutput) ServiceId 

func (o GetServiceEndpointConnectionsResultOutput) ServiceId() pulumi.StringOutput

func (GetServiceEndpointConnectionsResultOutput) ServiceName 

func (o GetServiceEndpointConnectionsResultOutput) ServiceName() pulumi.StringOutput

The name of the private link service.

func (GetServiceEndpointConnectionsResultOutput) ToGetServiceEndpointConnectionsResultOutput 

func (o GetServiceEndpointConnectionsResultOutput) ToGetServiceEndpointConnectionsResultOutput() GetServiceEndpointConnectionsResultOutput

func (GetServiceEndpointConnectionsResultOutput) ToGetServiceEndpointConnectionsResultOutputWithContext 

func (o GetServiceEndpointConnectionsResultOutput) ToGetServiceEndpointConnectionsResultOutputWithContext(ctx context.Context) GetServiceEndpointConnectionsResultOutput

type GetServiceNatIpConfiguration 

type GetServiceNatIpConfiguration struct {
	// The name of the private link service.
	Name string `pulumi:"name"`
	// Value that indicates if the IP configuration is the primary configuration or not.
	Primary bool `pulumi:"primary"`
	// The private IP address of the NAT IP configuration.
	PrivateIpAddress string `pulumi:"privateIpAddress"`
	// The version of the IP Protocol.
	PrivateIpAddressVersion string `pulumi:"privateIpAddressVersion"`
	// The ID of the subnet to be used by the service.
	SubnetId string `pulumi:"subnetId"`
}

type GetServiceNatIpConfigurationArgs 

type GetServiceNatIpConfigurationArgs struct {
	// The name of the private link service.
	Name pulumi.StringInput `pulumi:"name"`
	// Value that indicates if the IP configuration is the primary configuration or not.
	Primary pulumi.BoolInput `pulumi:"primary"`
	// The private IP address of the NAT IP configuration.
	PrivateIpAddress pulumi.StringInput `pulumi:"privateIpAddress"`
	// The version of the IP Protocol.
	PrivateIpAddressVersion pulumi.StringInput `pulumi:"privateIpAddressVersion"`
	// The ID of the subnet to be used by the service.
	SubnetId pulumi.StringInput `pulumi:"subnetId"`
}

func (GetServiceNatIpConfigurationArgs) ElementType 

func (GetServiceNatIpConfigurationArgs) ElementType() reflect.Type

func (GetServiceNatIpConfigurationArgs) ToGetServiceNatIpConfigurationOutput 

func (i GetServiceNatIpConfigurationArgs) ToGetServiceNatIpConfigurationOutput() GetServiceNatIpConfigurationOutput

func (GetServiceNatIpConfigurationArgs) ToGetServiceNatIpConfigurationOutputWithContext 

func (i GetServiceNatIpConfigurationArgs) ToGetServiceNatIpConfigurationOutputWithContext(ctx context.Context) GetServiceNatIpConfigurationOutput

type GetServiceNatIpConfigurationArray 

type GetServiceNatIpConfigurationArray []GetServiceNatIpConfigurationInput

func (GetServiceNatIpConfigurationArray) ElementType 

func (GetServiceNatIpConfigurationArray) ElementType() reflect.Type

func (GetServiceNatIpConfigurationArray) ToGetServiceNatIpConfigurationArrayOutput 

func (i GetServiceNatIpConfigurationArray) ToGetServiceNatIpConfigurationArrayOutput() GetServiceNatIpConfigurationArrayOutput

func (GetServiceNatIpConfigurationArray) ToGetServiceNatIpConfigurationArrayOutputWithContext 

func (i GetServiceNatIpConfigurationArray) ToGetServiceNatIpConfigurationArrayOutputWithContext(ctx context.Context) GetServiceNatIpConfigurationArrayOutput

type GetServiceNatIpConfigurationArrayInput 

type GetServiceNatIpConfigurationArrayInput interface {
	pulumi.Input

	ToGetServiceNatIpConfigurationArrayOutput() GetServiceNatIpConfigurationArrayOutput
	ToGetServiceNatIpConfigurationArrayOutputWithContext(context.Context) GetServiceNatIpConfigurationArrayOutput
}

GetServiceNatIpConfigurationArrayInput is an input type that accepts GetServiceNatIpConfigurationArray and GetServiceNatIpConfigurationArrayOutput values. You can construct a concrete instance of `GetServiceNatIpConfigurationArrayInput` via: 

GetServiceNatIpConfigurationArray{ GetServiceNatIpConfigurationArgs{...} }

type GetServiceNatIpConfigurationArrayOutput 

type GetServiceNatIpConfigurationArrayOutput struct{ *pulumi.OutputState }

func (GetServiceNatIpConfigurationArrayOutput) ElementType 

func (GetServiceNatIpConfigurationArrayOutput) ElementType() reflect.Type

func (GetServiceNatIpConfigurationArrayOutput) Index 

func (o GetServiceNatIpConfigurationArrayOutput) Index(i pulumi.IntInput) GetServiceNatIpConfigurationOutput

func (GetServiceNatIpConfigurationArrayOutput) ToGetServiceNatIpConfigurationArrayOutput 

func (o GetServiceNatIpConfigurationArrayOutput) ToGetServiceNatIpConfigurationArrayOutput() GetServiceNatIpConfigurationArrayOutput

func (GetServiceNatIpConfigurationArrayOutput) ToGetServiceNatIpConfigurationArrayOutputWithContext 

func (o GetServiceNatIpConfigurationArrayOutput) ToGetServiceNatIpConfigurationArrayOutputWithContext(ctx context.Context) GetServiceNatIpConfigurationArrayOutput

type GetServiceNatIpConfigurationInput 

type GetServiceNatIpConfigurationInput interface {
	pulumi.Input

	ToGetServiceNatIpConfigurationOutput() GetServiceNatIpConfigurationOutput
	ToGetServiceNatIpConfigurationOutputWithContext(context.Context) GetServiceNatIpConfigurationOutput
}

GetServiceNatIpConfigurationInput is an input type that accepts GetServiceNatIpConfigurationArgs and GetServiceNatIpConfigurationOutput values. You can construct a concrete instance of `GetServiceNatIpConfigurationInput` via: 

GetServiceNatIpConfigurationArgs{...}

type GetServiceNatIpConfigurationOutput 

type GetServiceNatIpConfigurationOutput struct{ *pulumi.OutputState }

func (GetServiceNatIpConfigurationOutput) ElementType 

func (GetServiceNatIpConfigurationOutput) ElementType() reflect.Type

func (GetServiceNatIpConfigurationOutput) Name 

func (o GetServiceNatIpConfigurationOutput) Name() pulumi.StringOutput

The name of the private link service.

func (GetServiceNatIpConfigurationOutput) Primary 

func (o GetServiceNatIpConfigurationOutput) Primary() pulumi.BoolOutput

Value that indicates if the IP configuration is the primary configuration or not.

func (GetServiceNatIpConfigurationOutput) PrivateIpAddress 

func (o GetServiceNatIpConfigurationOutput) PrivateIpAddress() pulumi.StringOutput

The private IP address of the NAT IP configuration.

func (GetServiceNatIpConfigurationOutput) PrivateIpAddressVersion 

func (o GetServiceNatIpConfigurationOutput) PrivateIpAddressVersion() pulumi.StringOutput

The version of the IP Protocol.

func (GetServiceNatIpConfigurationOutput) SubnetId 

func (o GetServiceNatIpConfigurationOutput) SubnetId() pulumi.StringOutput

The ID of the subnet to be used by the service.

func (GetServiceNatIpConfigurationOutput) ToGetServiceNatIpConfigurationOutput 

func (o GetServiceNatIpConfigurationOutput) ToGetServiceNatIpConfigurationOutput() GetServiceNatIpConfigurationOutput

func (GetServiceNatIpConfigurationOutput) ToGetServiceNatIpConfigurationOutputWithContext 

func (o GetServiceNatIpConfigurationOutput) ToGetServiceNatIpConfigurationOutputWithContext(ctx context.Context) GetServiceNatIpConfigurationOutput

type GetServiceOutputArgs 

type GetServiceOutputArgs struct {
	// The name of the private link service.
	Name pulumi.StringInput `pulumi:"name"`
	// The name of the resource group in which the private link service resides.
	ResourceGroupName pulumi.StringInput `pulumi:"resourceGroupName"`
}

A collection of arguments for invoking getService.

func (GetServiceOutputArgs) ElementType 

func (GetServiceOutputArgs) ElementType() reflect.Type

type GetServiceResult 

type GetServiceResult struct {
	// The alias is a globally unique name for your private link service which Azure generates for you. Your can use this alias to request a connection to your private link service.
	Alias string `pulumi:"alias"`
	// The list of subscription(s) globally unique identifiers that will be auto approved to use the private link service.
	AutoApprovalSubscriptionIds []string `pulumi:"autoApprovalSubscriptionIds"`
	// Does the Private Link Service support the Proxy Protocol?
	EnableProxyProtocol bool `pulumi:"enableProxyProtocol"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// The list of Standard Load Balancer(SLB) resource IDs. The Private Link service is tied to the frontend IP address of a SLB. All traffic destined for the private link service will reach the frontend of the SLB. You can configure SLB rules to direct this traffic to appropriate backend pools where your applications are running.
	LoadBalancerFrontendIpConfigurationIds []string `pulumi:"loadBalancerFrontendIpConfigurationIds"`
	// The supported Azure location where the resource exists.
	Location string `pulumi:"location"`
	// The name of private link service NAT IP configuration.
	Name string `pulumi:"name"`
	// The `natIpConfiguration` block as defined below.
	NatIpConfigurations []GetServiceNatIpConfiguration `pulumi:"natIpConfigurations"`
	ResourceGroupName   string                         `pulumi:"resourceGroupName"`
	// A mapping of tags to assign to the resource.
	Tags map[string]string `pulumi:"tags"`
	// The list of subscription(s) globally unique identifiers(GUID) that will be able to see the private link service.
	VisibilitySubscriptionIds []string `pulumi:"visibilitySubscriptionIds"`
}

A collection of values returned by getService.

func GetService 

func GetService(ctx *pulumi.Context, args *GetServiceArgs, opts ...pulumi.InvokeOption) (*GetServiceResult, error)

Use this data source to access information about an existing Private Link Service.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/privatelink"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := privatelink.GetService(ctx, &privatelink.GetServiceArgs{
			Name:              "myPrivateLinkService",
			ResourceGroupName: "PrivateLinkServiceRG",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("privateLinkServiceId", example.Id)
		return nil
	})
}

```

type GetServiceResultOutput 

type GetServiceResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getService.

func GetServiceOutput 

func GetServiceOutput(ctx *pulumi.Context, args GetServiceOutputArgs, opts ...pulumi.InvokeOption) GetServiceResultOutput

func (GetServiceResultOutput) Alias 

func (o GetServiceResultOutput) Alias() pulumi.StringOutput

The alias is a globally unique name for your private link service which Azure generates for you. Your can use this alias to request a connection to your private link service.

func (GetServiceResultOutput) AutoApprovalSubscriptionIds 

func (o GetServiceResultOutput) AutoApprovalSubscriptionIds() pulumi.StringArrayOutput

The list of subscription(s) globally unique identifiers that will be auto approved to use the private link service.

func (GetServiceResultOutput) ElementType 

func (GetServiceResultOutput) ElementType() reflect.Type

func (GetServiceResultOutput) EnableProxyProtocol 

func (o GetServiceResultOutput) EnableProxyProtocol() pulumi.BoolOutput

Does the Private Link Service support the Proxy Protocol?

func (GetServiceResultOutput) Id 

func (o GetServiceResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (GetServiceResultOutput) LoadBalancerFrontendIpConfigurationIds 

func (o GetServiceResultOutput) LoadBalancerFrontendIpConfigurationIds() pulumi.StringArrayOutput

The list of Standard Load Balancer(SLB) resource IDs. The Private Link service is tied to the frontend IP address of a SLB. All traffic destined for the private link service will reach the frontend of the SLB. You can configure SLB rules to direct this traffic to appropriate backend pools where your applications are running.

func (GetServiceResultOutput) Location 

func (o GetServiceResultOutput) Location() pulumi.StringOutput

The supported Azure location where the resource exists.

func (GetServiceResultOutput) Name 

func (o GetServiceResultOutput) Name() pulumi.StringOutput

The name of private link service NAT IP configuration.

func (GetServiceResultOutput) NatIpConfigurations 

func (o GetServiceResultOutput) NatIpConfigurations() GetServiceNatIpConfigurationArrayOutput

The `natIpConfiguration` block as defined below.

func (GetServiceResultOutput) ResourceGroupName 

func (o GetServiceResultOutput) ResourceGroupName() pulumi.StringOutput

func (GetServiceResultOutput) Tags 

func (o GetServiceResultOutput) Tags() pulumi.StringMapOutput

A mapping of tags to assign to the resource.

func (GetServiceResultOutput) ToGetServiceResultOutput 

func (o GetServiceResultOutput) ToGetServiceResultOutput() GetServiceResultOutput

func (GetServiceResultOutput) ToGetServiceResultOutputWithContext 

func (o GetServiceResultOutput) ToGetServiceResultOutputWithContext(ctx context.Context) GetServiceResultOutput

func (GetServiceResultOutput) VisibilitySubscriptionIds 

func (o GetServiceResultOutput) VisibilitySubscriptionIds() pulumi.StringArrayOutput

The list of subscription(s) globally unique identifiers(GUID) that will be able to see the private link service.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.