lb

package
v4.19.0 Latest Latest
Warning

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

 Go to latest Published: Sep 23, 2021 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 BackendAddressPool 

type BackendAddressPool struct {
	pulumi.CustomResourceState

	// Deprecated: This field is non-functional and will be removed in version 3.0 of the Azure Provider - use the separate `azurerm_lb_backend_address_pool_address` resource instead.
	BackendAddresses BackendAddressPoolBackendAddressArrayOutput `pulumi:"backendAddresses"`
	// The Backend IP Configurations associated with this Backend Address Pool.
	BackendIpConfigurations pulumi.StringArrayOutput `pulumi:"backendIpConfigurations"`
	// The Load Balancing Rules associated with this Backend Address Pool.
	LoadBalancingRules pulumi.StringArrayOutput `pulumi:"loadBalancingRules"`
	// The ID of the Load Balancer in which to create the Backend Address Pool.
	LoadbalancerId pulumi.StringOutput `pulumi:"loadbalancerId"`
	// Specifies the name of the Backend Address Pool.
	Name pulumi.StringOutput `pulumi:"name"`
	// An array of the Load Balancing Outbound Rules associated with this Backend Address Pool.
	OutboundRules pulumi.StringArrayOutput `pulumi:"outboundRules"`
	// Deprecated: This field is no longer used and will be removed in the next major version of the Azure Provider
	ResourceGroupName pulumi.StringOutput `pulumi:"resourceGroupName"`
}

Manages a Load Balancer Backend Address Pool.

> **NOTE:** When using this resource, the Load Balancer needs to have a FrontEnd IP Configuration Attached

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/lb"
"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/network"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		examplePublicIp, err := network.NewPublicIp(ctx, "examplePublicIp", &network.PublicIpArgs{
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
			AllocationMethod:  pulumi.String("Static"),
		})
		if err != nil {
			return err
		}
		exampleLoadBalancer, err := lb.NewLoadBalancer(ctx, "exampleLoadBalancer", &lb.LoadBalancerArgs{
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
			FrontendIpConfigurations: lb.LoadBalancerFrontendIpConfigurationArray{
				&lb.LoadBalancerFrontendIpConfigurationArgs{
					Name:              pulumi.String("PublicIPAddress"),
					PublicIpAddressId: examplePublicIp.ID(),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = lb.NewBackendAddressPool(ctx, "exampleBackendAddressPool", &lb.BackendAddressPoolArgs{
			LoadbalancerId: exampleLoadBalancer.ID(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Load Balancer Backend Address Pools can be imported using the `resource id`, e.g.

```sh 

$ pulumi import azure:lb/backendAddressPool:BackendAddressPool example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.Network/loadBalancers/lb1/backendAddressPools/pool1

```

func GetBackendAddressPool 

func GetBackendAddressPool(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *BackendAddressPoolState, opts ...pulumi.ResourceOption) (*BackendAddressPool, error)

GetBackendAddressPool gets an existing BackendAddressPool 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 NewBackendAddressPool 

func NewBackendAddressPool(ctx *pulumi.Context,
	name string, args *BackendAddressPoolArgs, opts ...pulumi.ResourceOption) (*BackendAddressPool, error)

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

func (*BackendAddressPool) ElementType 

func (*BackendAddressPool) ElementType() reflect.Type

func (*BackendAddressPool) ToBackendAddressPoolOutput 

func (i *BackendAddressPool) ToBackendAddressPoolOutput() BackendAddressPoolOutput

func (*BackendAddressPool) ToBackendAddressPoolOutputWithContext 

func (i *BackendAddressPool) ToBackendAddressPoolOutputWithContext(ctx context.Context) BackendAddressPoolOutput

func (*BackendAddressPool) ToBackendAddressPoolPtrOutput 

func (i *BackendAddressPool) ToBackendAddressPoolPtrOutput() BackendAddressPoolPtrOutput

func (*BackendAddressPool) ToBackendAddressPoolPtrOutputWithContext 

func (i *BackendAddressPool) ToBackendAddressPoolPtrOutputWithContext(ctx context.Context) BackendAddressPoolPtrOutput

type BackendAddressPoolAddress 

type BackendAddressPoolAddress struct {
	pulumi.CustomResourceState

	// The ID of the Backend Address Pool. Changing this forces a new Backend Address Pool Address to be created.
	BackendAddressPoolId pulumi.StringOutput `pulumi:"backendAddressPoolId"`
	// The Static IP Address which should be allocated to this Backend Address Pool.
	IpAddress pulumi.StringOutput `pulumi:"ipAddress"`
	// The name which should be used for this Backend Address Pool Address. Changing this forces a new Backend Address Pool Address to be created.
	Name pulumi.StringOutput `pulumi:"name"`
	// The ID of the Virtual Network within which the Backend Address Pool should exist.
	VirtualNetworkId pulumi.StringOutput `pulumi:"virtualNetworkId"`
}

Manages a Backend Address within a Backend Address Pool.

> **Note:** Backend Addresses can only be added to a `Standard` SKU Load Balancer.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/lb"
"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/network"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleVirtualNetwork, err := network.LookupVirtualNetwork(ctx, &network.LookupVirtualNetworkArgs{
			Name:              "example-network",
			ResourceGroupName: "example-resources",
		}, nil)
		if err != nil {
			return err
		}
		exampleLB, err := lb.GetLB(ctx, &lb.GetLBArgs{
			Name:              "example-lb",
			ResourceGroupName: "example-resources",
		}, nil)
		if err != nil {
			return err
		}
		exampleBackendAddressPool, err := lb.LookupBackendAddressPool(ctx, &lb.LookupBackendAddressPoolArgs{
			Name:           "first",
			LoadbalancerId: exampleLB.Id,
		}, nil)
		if err != nil {
			return err
		}
		_, err = lb.NewBackendAddressPoolAddress(ctx, "exampleBackendAddressPoolAddress", &lb.BackendAddressPoolAddressArgs{
			BackendAddressPoolId: pulumi.String(exampleBackendAddressPool.Id),
			VirtualNetworkId:     pulumi.String(exampleVirtualNetwork.Id),
			IpAddress:            pulumi.String("10.0.0.1"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Backend Address Pool Addresses can be imported using the `resource id`, e.g.

```sh 

$ pulumi import azure:lb/backendAddressPoolAddress:BackendAddressPoolAddress example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.Network/loadBalancers/loadBalancer1/backendAddressPools/backendAddressPool1/addresses/address1

```

func GetBackendAddressPoolAddress 

func GetBackendAddressPoolAddress(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *BackendAddressPoolAddressState, opts ...pulumi.ResourceOption) (*BackendAddressPoolAddress, error)

GetBackendAddressPoolAddress gets an existing BackendAddressPoolAddress 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 NewBackendAddressPoolAddress 

func NewBackendAddressPoolAddress(ctx *pulumi.Context,
	name string, args *BackendAddressPoolAddressArgs, opts ...pulumi.ResourceOption) (*BackendAddressPoolAddress, error)

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

func (*BackendAddressPoolAddress) ElementType 

func (*BackendAddressPoolAddress) ElementType() reflect.Type

func (*BackendAddressPoolAddress) ToBackendAddressPoolAddressOutput 

func (i *BackendAddressPoolAddress) ToBackendAddressPoolAddressOutput() BackendAddressPoolAddressOutput

func (*BackendAddressPoolAddress) ToBackendAddressPoolAddressOutputWithContext 

func (i *BackendAddressPoolAddress) ToBackendAddressPoolAddressOutputWithContext(ctx context.Context) BackendAddressPoolAddressOutput

func (*BackendAddressPoolAddress) ToBackendAddressPoolAddressPtrOutput 

func (i *BackendAddressPoolAddress) ToBackendAddressPoolAddressPtrOutput() BackendAddressPoolAddressPtrOutput

func (*BackendAddressPoolAddress) ToBackendAddressPoolAddressPtrOutputWithContext 

func (i *BackendAddressPoolAddress) ToBackendAddressPoolAddressPtrOutputWithContext(ctx context.Context) BackendAddressPoolAddressPtrOutput

type BackendAddressPoolAddressArgs 

type BackendAddressPoolAddressArgs struct {
	// The ID of the Backend Address Pool. Changing this forces a new Backend Address Pool Address to be created.
	BackendAddressPoolId pulumi.StringInput
	// The Static IP Address which should be allocated to this Backend Address Pool.
	IpAddress pulumi.StringInput
	// The name which should be used for this Backend Address Pool Address. Changing this forces a new Backend Address Pool Address to be created.
	Name pulumi.StringPtrInput
	// The ID of the Virtual Network within which the Backend Address Pool should exist.
	VirtualNetworkId pulumi.StringInput
}

The set of arguments for constructing a BackendAddressPoolAddress resource.

func (BackendAddressPoolAddressArgs) ElementType 

func (BackendAddressPoolAddressArgs) ElementType() reflect.Type

type BackendAddressPoolAddressArray 

type BackendAddressPoolAddressArray []BackendAddressPoolAddressInput

func (BackendAddressPoolAddressArray) ElementType 

func (BackendAddressPoolAddressArray) ElementType() reflect.Type

func (BackendAddressPoolAddressArray) ToBackendAddressPoolAddressArrayOutput 

func (i BackendAddressPoolAddressArray) ToBackendAddressPoolAddressArrayOutput() BackendAddressPoolAddressArrayOutput

func (BackendAddressPoolAddressArray) ToBackendAddressPoolAddressArrayOutputWithContext 

func (i BackendAddressPoolAddressArray) ToBackendAddressPoolAddressArrayOutputWithContext(ctx context.Context) BackendAddressPoolAddressArrayOutput

type BackendAddressPoolAddressArrayInput 

type BackendAddressPoolAddressArrayInput interface {
	pulumi.Input

	ToBackendAddressPoolAddressArrayOutput() BackendAddressPoolAddressArrayOutput
	ToBackendAddressPoolAddressArrayOutputWithContext(context.Context) BackendAddressPoolAddressArrayOutput
}

BackendAddressPoolAddressArrayInput is an input type that accepts BackendAddressPoolAddressArray and BackendAddressPoolAddressArrayOutput values. You can construct a concrete instance of `BackendAddressPoolAddressArrayInput` via: 

BackendAddressPoolAddressArray{ BackendAddressPoolAddressArgs{...} }

type BackendAddressPoolAddressArrayOutput 

type BackendAddressPoolAddressArrayOutput struct{ *pulumi.OutputState }

func (BackendAddressPoolAddressArrayOutput) ElementType 

func (BackendAddressPoolAddressArrayOutput) ElementType() reflect.Type

func (BackendAddressPoolAddressArrayOutput) Index 

func (o BackendAddressPoolAddressArrayOutput) Index(i pulumi.IntInput) BackendAddressPoolAddressOutput

func (BackendAddressPoolAddressArrayOutput) ToBackendAddressPoolAddressArrayOutput 

func (o BackendAddressPoolAddressArrayOutput) ToBackendAddressPoolAddressArrayOutput() BackendAddressPoolAddressArrayOutput

func (BackendAddressPoolAddressArrayOutput) ToBackendAddressPoolAddressArrayOutputWithContext 

func (o BackendAddressPoolAddressArrayOutput) ToBackendAddressPoolAddressArrayOutputWithContext(ctx context.Context) BackendAddressPoolAddressArrayOutput

type BackendAddressPoolAddressInput 

type BackendAddressPoolAddressInput interface {
	pulumi.Input

	ToBackendAddressPoolAddressOutput() BackendAddressPoolAddressOutput
	ToBackendAddressPoolAddressOutputWithContext(ctx context.Context) BackendAddressPoolAddressOutput
}

type BackendAddressPoolAddressMap 

type BackendAddressPoolAddressMap map[string]BackendAddressPoolAddressInput

func (BackendAddressPoolAddressMap) ElementType 

func (BackendAddressPoolAddressMap) ElementType() reflect.Type

func (BackendAddressPoolAddressMap) ToBackendAddressPoolAddressMapOutput 

func (i BackendAddressPoolAddressMap) ToBackendAddressPoolAddressMapOutput() BackendAddressPoolAddressMapOutput

func (BackendAddressPoolAddressMap) ToBackendAddressPoolAddressMapOutputWithContext 

func (i BackendAddressPoolAddressMap) ToBackendAddressPoolAddressMapOutputWithContext(ctx context.Context) BackendAddressPoolAddressMapOutput

type BackendAddressPoolAddressMapInput 

type BackendAddressPoolAddressMapInput interface {
	pulumi.Input

	ToBackendAddressPoolAddressMapOutput() BackendAddressPoolAddressMapOutput
	ToBackendAddressPoolAddressMapOutputWithContext(context.Context) BackendAddressPoolAddressMapOutput
}

BackendAddressPoolAddressMapInput is an input type that accepts BackendAddressPoolAddressMap and BackendAddressPoolAddressMapOutput values. You can construct a concrete instance of `BackendAddressPoolAddressMapInput` via: 

BackendAddressPoolAddressMap{ "key": BackendAddressPoolAddressArgs{...} }

type BackendAddressPoolAddressMapOutput 

type BackendAddressPoolAddressMapOutput struct{ *pulumi.OutputState }

func (BackendAddressPoolAddressMapOutput) ElementType 

func (BackendAddressPoolAddressMapOutput) ElementType() reflect.Type

func (BackendAddressPoolAddressMapOutput) MapIndex 

func (o BackendAddressPoolAddressMapOutput) MapIndex(k pulumi.StringInput) BackendAddressPoolAddressOutput

func (BackendAddressPoolAddressMapOutput) ToBackendAddressPoolAddressMapOutput 

func (o BackendAddressPoolAddressMapOutput) ToBackendAddressPoolAddressMapOutput() BackendAddressPoolAddressMapOutput

func (BackendAddressPoolAddressMapOutput) ToBackendAddressPoolAddressMapOutputWithContext 

func (o BackendAddressPoolAddressMapOutput) ToBackendAddressPoolAddressMapOutputWithContext(ctx context.Context) BackendAddressPoolAddressMapOutput

type BackendAddressPoolAddressOutput 

type BackendAddressPoolAddressOutput struct {
	*pulumi.OutputState
}

func (BackendAddressPoolAddressOutput) ElementType 

func (BackendAddressPoolAddressOutput) ElementType() reflect.Type

func (BackendAddressPoolAddressOutput) ToBackendAddressPoolAddressOutput 

func (o BackendAddressPoolAddressOutput) ToBackendAddressPoolAddressOutput() BackendAddressPoolAddressOutput

func (BackendAddressPoolAddressOutput) ToBackendAddressPoolAddressOutputWithContext 

func (o BackendAddressPoolAddressOutput) ToBackendAddressPoolAddressOutputWithContext(ctx context.Context) BackendAddressPoolAddressOutput

func (BackendAddressPoolAddressOutput) ToBackendAddressPoolAddressPtrOutput 

func (o BackendAddressPoolAddressOutput) ToBackendAddressPoolAddressPtrOutput() BackendAddressPoolAddressPtrOutput

func (BackendAddressPoolAddressOutput) ToBackendAddressPoolAddressPtrOutputWithContext 

func (o BackendAddressPoolAddressOutput) ToBackendAddressPoolAddressPtrOutputWithContext(ctx context.Context) BackendAddressPoolAddressPtrOutput

type BackendAddressPoolAddressPtrInput 

type BackendAddressPoolAddressPtrInput interface {
	pulumi.Input

	ToBackendAddressPoolAddressPtrOutput() BackendAddressPoolAddressPtrOutput
	ToBackendAddressPoolAddressPtrOutputWithContext(ctx context.Context) BackendAddressPoolAddressPtrOutput
}

type BackendAddressPoolAddressPtrOutput 

type BackendAddressPoolAddressPtrOutput struct {
	*pulumi.OutputState
}

func (BackendAddressPoolAddressPtrOutput) ElementType 

func (BackendAddressPoolAddressPtrOutput) ElementType() reflect.Type

func (BackendAddressPoolAddressPtrOutput) ToBackendAddressPoolAddressPtrOutput 

func (o BackendAddressPoolAddressPtrOutput) ToBackendAddressPoolAddressPtrOutput() BackendAddressPoolAddressPtrOutput

func (BackendAddressPoolAddressPtrOutput) ToBackendAddressPoolAddressPtrOutputWithContext 

func (o BackendAddressPoolAddressPtrOutput) ToBackendAddressPoolAddressPtrOutputWithContext(ctx context.Context) BackendAddressPoolAddressPtrOutput

type BackendAddressPoolAddressState 

type BackendAddressPoolAddressState struct {
	// The ID of the Backend Address Pool. Changing this forces a new Backend Address Pool Address to be created.
	BackendAddressPoolId pulumi.StringPtrInput
	// The Static IP Address which should be allocated to this Backend Address Pool.
	IpAddress pulumi.StringPtrInput
	// The name which should be used for this Backend Address Pool Address. Changing this forces a new Backend Address Pool Address to be created.
	Name pulumi.StringPtrInput
	// The ID of the Virtual Network within which the Backend Address Pool should exist.
	VirtualNetworkId pulumi.StringPtrInput
}

func (BackendAddressPoolAddressState) ElementType 

func (BackendAddressPoolAddressState) ElementType() reflect.Type

type BackendAddressPoolArgs 

type BackendAddressPoolArgs struct {
	// Deprecated: This field is non-functional and will be removed in version 3.0 of the Azure Provider - use the separate `azurerm_lb_backend_address_pool_address` resource instead.
	BackendAddresses BackendAddressPoolBackendAddressArrayInput
	// The ID of the Load Balancer in which to create the Backend Address Pool.
	LoadbalancerId pulumi.StringInput
	// Specifies the name of the Backend Address Pool.
	Name pulumi.StringPtrInput
	// Deprecated: This field is no longer used and will be removed in the next major version of the Azure Provider
	ResourceGroupName pulumi.StringPtrInput
}

The set of arguments for constructing a BackendAddressPool resource.

func (BackendAddressPoolArgs) ElementType 

func (BackendAddressPoolArgs) ElementType() reflect.Type

type BackendAddressPoolArray 

type BackendAddressPoolArray []BackendAddressPoolInput

func (BackendAddressPoolArray) ElementType 

func (BackendAddressPoolArray) ElementType() reflect.Type

func (BackendAddressPoolArray) ToBackendAddressPoolArrayOutput 

func (i BackendAddressPoolArray) ToBackendAddressPoolArrayOutput() BackendAddressPoolArrayOutput

func (BackendAddressPoolArray) ToBackendAddressPoolArrayOutputWithContext 

func (i BackendAddressPoolArray) ToBackendAddressPoolArrayOutputWithContext(ctx context.Context) BackendAddressPoolArrayOutput

type BackendAddressPoolArrayInput 

type BackendAddressPoolArrayInput interface {
	pulumi.Input

	ToBackendAddressPoolArrayOutput() BackendAddressPoolArrayOutput
	ToBackendAddressPoolArrayOutputWithContext(context.Context) BackendAddressPoolArrayOutput
}

BackendAddressPoolArrayInput is an input type that accepts BackendAddressPoolArray and BackendAddressPoolArrayOutput values. You can construct a concrete instance of `BackendAddressPoolArrayInput` via: 

BackendAddressPoolArray{ BackendAddressPoolArgs{...} }

type BackendAddressPoolArrayOutput 

type BackendAddressPoolArrayOutput struct{ *pulumi.OutputState }

func (BackendAddressPoolArrayOutput) ElementType 

func (BackendAddressPoolArrayOutput) ElementType() reflect.Type

func (BackendAddressPoolArrayOutput) Index 

func (o BackendAddressPoolArrayOutput) Index(i pulumi.IntInput) BackendAddressPoolOutput

func (BackendAddressPoolArrayOutput) ToBackendAddressPoolArrayOutput 

func (o BackendAddressPoolArrayOutput) ToBackendAddressPoolArrayOutput() BackendAddressPoolArrayOutput

func (BackendAddressPoolArrayOutput) ToBackendAddressPoolArrayOutputWithContext 

func (o BackendAddressPoolArrayOutput) ToBackendAddressPoolArrayOutputWithContext(ctx context.Context) BackendAddressPoolArrayOutput

type BackendAddressPoolBackendAddress 

type BackendAddressPoolBackendAddress struct {
	IpAddress string `pulumi:"ipAddress"`
	// Specifies the name of the Backend Address Pool.
	Name             string `pulumi:"name"`
	VirtualNetworkId string `pulumi:"virtualNetworkId"`
}

type BackendAddressPoolBackendAddressArgs 

type BackendAddressPoolBackendAddressArgs struct {
	IpAddress pulumi.StringInput `pulumi:"ipAddress"`
	// Specifies the name of the Backend Address Pool.
	Name             pulumi.StringInput `pulumi:"name"`
	VirtualNetworkId pulumi.StringInput `pulumi:"virtualNetworkId"`
}

func (BackendAddressPoolBackendAddressArgs) ElementType 

func (BackendAddressPoolBackendAddressArgs) ElementType() reflect.Type

func (BackendAddressPoolBackendAddressArgs) ToBackendAddressPoolBackendAddressOutput 

func (i BackendAddressPoolBackendAddressArgs) ToBackendAddressPoolBackendAddressOutput() BackendAddressPoolBackendAddressOutput

func (BackendAddressPoolBackendAddressArgs) ToBackendAddressPoolBackendAddressOutputWithContext 

func (i BackendAddressPoolBackendAddressArgs) ToBackendAddressPoolBackendAddressOutputWithContext(ctx context.Context) BackendAddressPoolBackendAddressOutput

type BackendAddressPoolBackendAddressArray 

type BackendAddressPoolBackendAddressArray []BackendAddressPoolBackendAddressInput

func (BackendAddressPoolBackendAddressArray) ElementType 

func (BackendAddressPoolBackendAddressArray) ElementType() reflect.Type

func (BackendAddressPoolBackendAddressArray) ToBackendAddressPoolBackendAddressArrayOutput 

func (i BackendAddressPoolBackendAddressArray) ToBackendAddressPoolBackendAddressArrayOutput() BackendAddressPoolBackendAddressArrayOutput

func (BackendAddressPoolBackendAddressArray) ToBackendAddressPoolBackendAddressArrayOutputWithContext 

func (i BackendAddressPoolBackendAddressArray) ToBackendAddressPoolBackendAddressArrayOutputWithContext(ctx context.Context) BackendAddressPoolBackendAddressArrayOutput

type BackendAddressPoolBackendAddressArrayInput 

type BackendAddressPoolBackendAddressArrayInput interface {
	pulumi.Input

	ToBackendAddressPoolBackendAddressArrayOutput() BackendAddressPoolBackendAddressArrayOutput
	ToBackendAddressPoolBackendAddressArrayOutputWithContext(context.Context) BackendAddressPoolBackendAddressArrayOutput
}

BackendAddressPoolBackendAddressArrayInput is an input type that accepts BackendAddressPoolBackendAddressArray and BackendAddressPoolBackendAddressArrayOutput values. You can construct a concrete instance of `BackendAddressPoolBackendAddressArrayInput` via: 

BackendAddressPoolBackendAddressArray{ BackendAddressPoolBackendAddressArgs{...} }

type BackendAddressPoolBackendAddressArrayOutput 

type BackendAddressPoolBackendAddressArrayOutput struct{ *pulumi.OutputState }

func (BackendAddressPoolBackendAddressArrayOutput) ElementType 

func (BackendAddressPoolBackendAddressArrayOutput) ElementType() reflect.Type

func (BackendAddressPoolBackendAddressArrayOutput) Index 

func (o BackendAddressPoolBackendAddressArrayOutput) Index(i pulumi.IntInput) BackendAddressPoolBackendAddressOutput

func (BackendAddressPoolBackendAddressArrayOutput) ToBackendAddressPoolBackendAddressArrayOutput 

func (o BackendAddressPoolBackendAddressArrayOutput) ToBackendAddressPoolBackendAddressArrayOutput() BackendAddressPoolBackendAddressArrayOutput

func (BackendAddressPoolBackendAddressArrayOutput) ToBackendAddressPoolBackendAddressArrayOutputWithContext 

func (o BackendAddressPoolBackendAddressArrayOutput) ToBackendAddressPoolBackendAddressArrayOutputWithContext(ctx context.Context) BackendAddressPoolBackendAddressArrayOutput

type BackendAddressPoolBackendAddressInput 

type BackendAddressPoolBackendAddressInput interface {
	pulumi.Input

	ToBackendAddressPoolBackendAddressOutput() BackendAddressPoolBackendAddressOutput
	ToBackendAddressPoolBackendAddressOutputWithContext(context.Context) BackendAddressPoolBackendAddressOutput
}

BackendAddressPoolBackendAddressInput is an input type that accepts BackendAddressPoolBackendAddressArgs and BackendAddressPoolBackendAddressOutput values. You can construct a concrete instance of `BackendAddressPoolBackendAddressInput` via: 

BackendAddressPoolBackendAddressArgs{...}

type BackendAddressPoolBackendAddressOutput 

type BackendAddressPoolBackendAddressOutput struct{ *pulumi.OutputState }

func (BackendAddressPoolBackendAddressOutput) ElementType 

func (BackendAddressPoolBackendAddressOutput) ElementType() reflect.Type

func (BackendAddressPoolBackendAddressOutput) IpAddress 

func (o BackendAddressPoolBackendAddressOutput) IpAddress() pulumi.StringOutput

func (BackendAddressPoolBackendAddressOutput) Name 

func (o BackendAddressPoolBackendAddressOutput) Name() pulumi.StringOutput

Specifies the name of the Backend Address Pool.

func (BackendAddressPoolBackendAddressOutput) ToBackendAddressPoolBackendAddressOutput 

func (o BackendAddressPoolBackendAddressOutput) ToBackendAddressPoolBackendAddressOutput() BackendAddressPoolBackendAddressOutput

func (BackendAddressPoolBackendAddressOutput) ToBackendAddressPoolBackendAddressOutputWithContext 

func (o BackendAddressPoolBackendAddressOutput) ToBackendAddressPoolBackendAddressOutputWithContext(ctx context.Context) BackendAddressPoolBackendAddressOutput

func (BackendAddressPoolBackendAddressOutput) VirtualNetworkId 

func (o BackendAddressPoolBackendAddressOutput) VirtualNetworkId() pulumi.StringOutput

type BackendAddressPoolInput 

type BackendAddressPoolInput interface {
	pulumi.Input

	ToBackendAddressPoolOutput() BackendAddressPoolOutput
	ToBackendAddressPoolOutputWithContext(ctx context.Context) BackendAddressPoolOutput
}

type BackendAddressPoolMap 

type BackendAddressPoolMap map[string]BackendAddressPoolInput

func (BackendAddressPoolMap) ElementType 

func (BackendAddressPoolMap) ElementType() reflect.Type

func (BackendAddressPoolMap) ToBackendAddressPoolMapOutput 

func (i BackendAddressPoolMap) ToBackendAddressPoolMapOutput() BackendAddressPoolMapOutput

func (BackendAddressPoolMap) ToBackendAddressPoolMapOutputWithContext 

func (i BackendAddressPoolMap) ToBackendAddressPoolMapOutputWithContext(ctx context.Context) BackendAddressPoolMapOutput

type BackendAddressPoolMapInput 

type BackendAddressPoolMapInput interface {
	pulumi.Input

	ToBackendAddressPoolMapOutput() BackendAddressPoolMapOutput
	ToBackendAddressPoolMapOutputWithContext(context.Context) BackendAddressPoolMapOutput
}

BackendAddressPoolMapInput is an input type that accepts BackendAddressPoolMap and BackendAddressPoolMapOutput values. You can construct a concrete instance of `BackendAddressPoolMapInput` via: 

BackendAddressPoolMap{ "key": BackendAddressPoolArgs{...} }

type BackendAddressPoolMapOutput 

type BackendAddressPoolMapOutput struct{ *pulumi.OutputState }

func (BackendAddressPoolMapOutput) ElementType 

func (BackendAddressPoolMapOutput) ElementType() reflect.Type

func (BackendAddressPoolMapOutput) MapIndex 

func (o BackendAddressPoolMapOutput) MapIndex(k pulumi.StringInput) BackendAddressPoolOutput

func (BackendAddressPoolMapOutput) ToBackendAddressPoolMapOutput 

func (o BackendAddressPoolMapOutput) ToBackendAddressPoolMapOutput() BackendAddressPoolMapOutput

func (BackendAddressPoolMapOutput) ToBackendAddressPoolMapOutputWithContext 

func (o BackendAddressPoolMapOutput) ToBackendAddressPoolMapOutputWithContext(ctx context.Context) BackendAddressPoolMapOutput

type BackendAddressPoolOutput 

type BackendAddressPoolOutput struct {
	*pulumi.OutputState
}

func (BackendAddressPoolOutput) ElementType 

func (BackendAddressPoolOutput) ElementType() reflect.Type

func (BackendAddressPoolOutput) ToBackendAddressPoolOutput 

func (o BackendAddressPoolOutput) ToBackendAddressPoolOutput() BackendAddressPoolOutput

func (BackendAddressPoolOutput) ToBackendAddressPoolOutputWithContext 

func (o BackendAddressPoolOutput) ToBackendAddressPoolOutputWithContext(ctx context.Context) BackendAddressPoolOutput

func (BackendAddressPoolOutput) ToBackendAddressPoolPtrOutput 

func (o BackendAddressPoolOutput) ToBackendAddressPoolPtrOutput() BackendAddressPoolPtrOutput

func (BackendAddressPoolOutput) ToBackendAddressPoolPtrOutputWithContext 

func (o BackendAddressPoolOutput) ToBackendAddressPoolPtrOutputWithContext(ctx context.Context) BackendAddressPoolPtrOutput

type BackendAddressPoolPtrInput 

type BackendAddressPoolPtrInput interface {
	pulumi.Input

	ToBackendAddressPoolPtrOutput() BackendAddressPoolPtrOutput
	ToBackendAddressPoolPtrOutputWithContext(ctx context.Context) BackendAddressPoolPtrOutput
}

type BackendAddressPoolPtrOutput 

type BackendAddressPoolPtrOutput struct {
	*pulumi.OutputState
}

func (BackendAddressPoolPtrOutput) ElementType 

func (BackendAddressPoolPtrOutput) ElementType() reflect.Type

func (BackendAddressPoolPtrOutput) ToBackendAddressPoolPtrOutput 

func (o BackendAddressPoolPtrOutput) ToBackendAddressPoolPtrOutput() BackendAddressPoolPtrOutput

func (BackendAddressPoolPtrOutput) ToBackendAddressPoolPtrOutputWithContext 

func (o BackendAddressPoolPtrOutput) ToBackendAddressPoolPtrOutputWithContext(ctx context.Context) BackendAddressPoolPtrOutput

type BackendAddressPoolState 

type BackendAddressPoolState struct {
	// Deprecated: This field is non-functional and will be removed in version 3.0 of the Azure Provider - use the separate `azurerm_lb_backend_address_pool_address` resource instead.
	BackendAddresses BackendAddressPoolBackendAddressArrayInput
	// The Backend IP Configurations associated with this Backend Address Pool.
	BackendIpConfigurations pulumi.StringArrayInput
	// The Load Balancing Rules associated with this Backend Address Pool.
	LoadBalancingRules pulumi.StringArrayInput
	// The ID of the Load Balancer in which to create the Backend Address Pool.
	LoadbalancerId pulumi.StringPtrInput
	// Specifies the name of the Backend Address Pool.
	Name pulumi.StringPtrInput
	// An array of the Load Balancing Outbound Rules associated with this Backend Address Pool.
	OutboundRules pulumi.StringArrayInput
	// Deprecated: This field is no longer used and will be removed in the next major version of the Azure Provider
	ResourceGroupName pulumi.StringPtrInput
}

func (BackendAddressPoolState) ElementType 

func (BackendAddressPoolState) ElementType() reflect.Type

type GetBackendAddressPoolBackendAddress 

type GetBackendAddressPoolBackendAddress struct {
	// The Static IP address for this Load Balancer within the Virtual Network.
	IpAddress string `pulumi:"ipAddress"`
	// Specifies the name of the Backend Address Pool.
	Name string `pulumi:"name"`
	// The ID of the Virtual Network where the Backend Address of the Load Balancer exists.
	VirtualNetworkId string `pulumi:"virtualNetworkId"`
}

type GetBackendAddressPoolBackendAddressArgs 

type GetBackendAddressPoolBackendAddressArgs struct {
	// The Static IP address for this Load Balancer within the Virtual Network.
	IpAddress pulumi.StringInput `pulumi:"ipAddress"`
	// Specifies the name of the Backend Address Pool.
	Name pulumi.StringInput `pulumi:"name"`
	// The ID of the Virtual Network where the Backend Address of the Load Balancer exists.
	VirtualNetworkId pulumi.StringInput `pulumi:"virtualNetworkId"`
}

func (GetBackendAddressPoolBackendAddressArgs) ElementType 

func (GetBackendAddressPoolBackendAddressArgs) ElementType() reflect.Type

func (GetBackendAddressPoolBackendAddressArgs) ToGetBackendAddressPoolBackendAddressOutput 

func (i GetBackendAddressPoolBackendAddressArgs) ToGetBackendAddressPoolBackendAddressOutput() GetBackendAddressPoolBackendAddressOutput

func (GetBackendAddressPoolBackendAddressArgs) ToGetBackendAddressPoolBackendAddressOutputWithContext 

func (i GetBackendAddressPoolBackendAddressArgs) ToGetBackendAddressPoolBackendAddressOutputWithContext(ctx context.Context) GetBackendAddressPoolBackendAddressOutput

type GetBackendAddressPoolBackendAddressArray 

type GetBackendAddressPoolBackendAddressArray []GetBackendAddressPoolBackendAddressInput

func (GetBackendAddressPoolBackendAddressArray) ElementType 

func (GetBackendAddressPoolBackendAddressArray) ElementType() reflect.Type

func (GetBackendAddressPoolBackendAddressArray) ToGetBackendAddressPoolBackendAddressArrayOutput 

func (i GetBackendAddressPoolBackendAddressArray) ToGetBackendAddressPoolBackendAddressArrayOutput() GetBackendAddressPoolBackendAddressArrayOutput

func (GetBackendAddressPoolBackendAddressArray) ToGetBackendAddressPoolBackendAddressArrayOutputWithContext 

func (i GetBackendAddressPoolBackendAddressArray) ToGetBackendAddressPoolBackendAddressArrayOutputWithContext(ctx context.Context) GetBackendAddressPoolBackendAddressArrayOutput

type GetBackendAddressPoolBackendAddressArrayInput 

type GetBackendAddressPoolBackendAddressArrayInput interface {
	pulumi.Input

	ToGetBackendAddressPoolBackendAddressArrayOutput() GetBackendAddressPoolBackendAddressArrayOutput
	ToGetBackendAddressPoolBackendAddressArrayOutputWithContext(context.Context) GetBackendAddressPoolBackendAddressArrayOutput
}

GetBackendAddressPoolBackendAddressArrayInput is an input type that accepts GetBackendAddressPoolBackendAddressArray and GetBackendAddressPoolBackendAddressArrayOutput values. You can construct a concrete instance of `GetBackendAddressPoolBackendAddressArrayInput` via: 

GetBackendAddressPoolBackendAddressArray{ GetBackendAddressPoolBackendAddressArgs{...} }

type GetBackendAddressPoolBackendAddressArrayOutput 

type GetBackendAddressPoolBackendAddressArrayOutput struct{ *pulumi.OutputState }

func (GetBackendAddressPoolBackendAddressArrayOutput) ElementType 

func (GetBackendAddressPoolBackendAddressArrayOutput) ElementType() reflect.Type

func (GetBackendAddressPoolBackendAddressArrayOutput) Index 

func (o GetBackendAddressPoolBackendAddressArrayOutput) Index(i pulumi.IntInput) GetBackendAddressPoolBackendAddressOutput

func (GetBackendAddressPoolBackendAddressArrayOutput) ToGetBackendAddressPoolBackendAddressArrayOutput 

func (o GetBackendAddressPoolBackendAddressArrayOutput) ToGetBackendAddressPoolBackendAddressArrayOutput() GetBackendAddressPoolBackendAddressArrayOutput

func (GetBackendAddressPoolBackendAddressArrayOutput) ToGetBackendAddressPoolBackendAddressArrayOutputWithContext 

func (o GetBackendAddressPoolBackendAddressArrayOutput) ToGetBackendAddressPoolBackendAddressArrayOutputWithContext(ctx context.Context) GetBackendAddressPoolBackendAddressArrayOutput

type GetBackendAddressPoolBackendAddressInput 

type GetBackendAddressPoolBackendAddressInput interface {
	pulumi.Input

	ToGetBackendAddressPoolBackendAddressOutput() GetBackendAddressPoolBackendAddressOutput
	ToGetBackendAddressPoolBackendAddressOutputWithContext(context.Context) GetBackendAddressPoolBackendAddressOutput
}

GetBackendAddressPoolBackendAddressInput is an input type that accepts GetBackendAddressPoolBackendAddressArgs and GetBackendAddressPoolBackendAddressOutput values. You can construct a concrete instance of `GetBackendAddressPoolBackendAddressInput` via: 

GetBackendAddressPoolBackendAddressArgs{...}

type GetBackendAddressPoolBackendAddressOutput 

type GetBackendAddressPoolBackendAddressOutput struct{ *pulumi.OutputState }

func (GetBackendAddressPoolBackendAddressOutput) ElementType 

func (GetBackendAddressPoolBackendAddressOutput) ElementType() reflect.Type

func (GetBackendAddressPoolBackendAddressOutput) IpAddress 

func (o GetBackendAddressPoolBackendAddressOutput) IpAddress() pulumi.StringOutput

The Static IP address for this Load Balancer within the Virtual Network.

func (GetBackendAddressPoolBackendAddressOutput) Name 

func (o GetBackendAddressPoolBackendAddressOutput) Name() pulumi.StringOutput

Specifies the name of the Backend Address Pool.

func (GetBackendAddressPoolBackendAddressOutput) ToGetBackendAddressPoolBackendAddressOutput 

func (o GetBackendAddressPoolBackendAddressOutput) ToGetBackendAddressPoolBackendAddressOutput() GetBackendAddressPoolBackendAddressOutput

func (GetBackendAddressPoolBackendAddressOutput) ToGetBackendAddressPoolBackendAddressOutputWithContext 

func (o GetBackendAddressPoolBackendAddressOutput) ToGetBackendAddressPoolBackendAddressOutputWithContext(ctx context.Context) GetBackendAddressPoolBackendAddressOutput

func (GetBackendAddressPoolBackendAddressOutput) VirtualNetworkId 

func (o GetBackendAddressPoolBackendAddressOutput) VirtualNetworkId() pulumi.StringOutput

The ID of the Virtual Network where the Backend Address of the Load Balancer exists.

type GetBackendAddressPoolBackendIpConfiguration 

type GetBackendAddressPoolBackendIpConfiguration struct {
	// The ID of the Backend Address Pool.
	Id string `pulumi:"id"`
}

type GetBackendAddressPoolBackendIpConfigurationArgs 

type GetBackendAddressPoolBackendIpConfigurationArgs struct {
	// The ID of the Backend Address Pool.
	Id pulumi.StringInput `pulumi:"id"`
}

func (GetBackendAddressPoolBackendIpConfigurationArgs) ElementType 

func (GetBackendAddressPoolBackendIpConfigurationArgs) ElementType() reflect.Type

func (GetBackendAddressPoolBackendIpConfigurationArgs) ToGetBackendAddressPoolBackendIpConfigurationOutput 

func (i GetBackendAddressPoolBackendIpConfigurationArgs) ToGetBackendAddressPoolBackendIpConfigurationOutput() GetBackendAddressPoolBackendIpConfigurationOutput

func (GetBackendAddressPoolBackendIpConfigurationArgs) ToGetBackendAddressPoolBackendIpConfigurationOutputWithContext 

func (i GetBackendAddressPoolBackendIpConfigurationArgs) ToGetBackendAddressPoolBackendIpConfigurationOutputWithContext(ctx context.Context) GetBackendAddressPoolBackendIpConfigurationOutput

type GetBackendAddressPoolBackendIpConfigurationArray 

type GetBackendAddressPoolBackendIpConfigurationArray []GetBackendAddressPoolBackendIpConfigurationInput

func (GetBackendAddressPoolBackendIpConfigurationArray) ElementType 

func (GetBackendAddressPoolBackendIpConfigurationArray) ElementType() reflect.Type

func (GetBackendAddressPoolBackendIpConfigurationArray) ToGetBackendAddressPoolBackendIpConfigurationArrayOutput 

func (i GetBackendAddressPoolBackendIpConfigurationArray) ToGetBackendAddressPoolBackendIpConfigurationArrayOutput() GetBackendAddressPoolBackendIpConfigurationArrayOutput

func (GetBackendAddressPoolBackendIpConfigurationArray) ToGetBackendAddressPoolBackendIpConfigurationArrayOutputWithContext 

func (i GetBackendAddressPoolBackendIpConfigurationArray) ToGetBackendAddressPoolBackendIpConfigurationArrayOutputWithContext(ctx context.Context) GetBackendAddressPoolBackendIpConfigurationArrayOutput

type GetBackendAddressPoolBackendIpConfigurationArrayInput 

type GetBackendAddressPoolBackendIpConfigurationArrayInput interface {
	pulumi.Input

	ToGetBackendAddressPoolBackendIpConfigurationArrayOutput() GetBackendAddressPoolBackendIpConfigurationArrayOutput
	ToGetBackendAddressPoolBackendIpConfigurationArrayOutputWithContext(context.Context) GetBackendAddressPoolBackendIpConfigurationArrayOutput
}

GetBackendAddressPoolBackendIpConfigurationArrayInput is an input type that accepts GetBackendAddressPoolBackendIpConfigurationArray and GetBackendAddressPoolBackendIpConfigurationArrayOutput values. You can construct a concrete instance of `GetBackendAddressPoolBackendIpConfigurationArrayInput` via: 

GetBackendAddressPoolBackendIpConfigurationArray{ GetBackendAddressPoolBackendIpConfigurationArgs{...} }

type GetBackendAddressPoolBackendIpConfigurationArrayOutput 

type GetBackendAddressPoolBackendIpConfigurationArrayOutput struct{ *pulumi.OutputState }

func (GetBackendAddressPoolBackendIpConfigurationArrayOutput) ElementType 

func (GetBackendAddressPoolBackendIpConfigurationArrayOutput) ElementType() reflect.Type

func (GetBackendAddressPoolBackendIpConfigurationArrayOutput) Index 

func (o GetBackendAddressPoolBackendIpConfigurationArrayOutput) Index(i pulumi.IntInput) GetBackendAddressPoolBackendIpConfigurationOutput

func (GetBackendAddressPoolBackendIpConfigurationArrayOutput) ToGetBackendAddressPoolBackendIpConfigurationArrayOutput 

func (o GetBackendAddressPoolBackendIpConfigurationArrayOutput) ToGetBackendAddressPoolBackendIpConfigurationArrayOutput() GetBackendAddressPoolBackendIpConfigurationArrayOutput

func (GetBackendAddressPoolBackendIpConfigurationArrayOutput) ToGetBackendAddressPoolBackendIpConfigurationArrayOutputWithContext 

func (o GetBackendAddressPoolBackendIpConfigurationArrayOutput) ToGetBackendAddressPoolBackendIpConfigurationArrayOutputWithContext(ctx context.Context) GetBackendAddressPoolBackendIpConfigurationArrayOutput

type GetBackendAddressPoolBackendIpConfigurationInput 

type GetBackendAddressPoolBackendIpConfigurationInput interface {
	pulumi.Input

	ToGetBackendAddressPoolBackendIpConfigurationOutput() GetBackendAddressPoolBackendIpConfigurationOutput
	ToGetBackendAddressPoolBackendIpConfigurationOutputWithContext(context.Context) GetBackendAddressPoolBackendIpConfigurationOutput
}

GetBackendAddressPoolBackendIpConfigurationInput is an input type that accepts GetBackendAddressPoolBackendIpConfigurationArgs and GetBackendAddressPoolBackendIpConfigurationOutput values. You can construct a concrete instance of `GetBackendAddressPoolBackendIpConfigurationInput` via: 

GetBackendAddressPoolBackendIpConfigurationArgs{...}

type GetBackendAddressPoolBackendIpConfigurationOutput 

type GetBackendAddressPoolBackendIpConfigurationOutput struct{ *pulumi.OutputState }

func (GetBackendAddressPoolBackendIpConfigurationOutput) ElementType 

func (GetBackendAddressPoolBackendIpConfigurationOutput) ElementType() reflect.Type

func (GetBackendAddressPoolBackendIpConfigurationOutput) Id 

func (o GetBackendAddressPoolBackendIpConfigurationOutput) Id() pulumi.StringOutput

The ID of the Backend Address Pool.

func (GetBackendAddressPoolBackendIpConfigurationOutput) ToGetBackendAddressPoolBackendIpConfigurationOutput 

func (o GetBackendAddressPoolBackendIpConfigurationOutput) ToGetBackendAddressPoolBackendIpConfigurationOutput() GetBackendAddressPoolBackendIpConfigurationOutput

func (GetBackendAddressPoolBackendIpConfigurationOutput) ToGetBackendAddressPoolBackendIpConfigurationOutputWithContext 

func (o GetBackendAddressPoolBackendIpConfigurationOutput) ToGetBackendAddressPoolBackendIpConfigurationOutputWithContext(ctx context.Context) GetBackendAddressPoolBackendIpConfigurationOutput

type GetLBArgs 

type GetLBArgs struct {
	// Specifies the name of the Load Balancer.
	Name string `pulumi:"name"`
	// The name of the Resource Group in which the Load Balancer exists.
	ResourceGroupName string `pulumi:"resourceGroupName"`
}

A collection of arguments for invoking getLB.

type GetLBFrontendIpConfiguration 

type GetLBFrontendIpConfiguration struct {
	// The id of the Frontend IP Configuration.
	Id string `pulumi:"id"`
	// Specifies the name of the Load Balancer.
	Name string `pulumi:"name"`
	// Private IP Address to assign to the Load Balancer.
	PrivateIpAddress string `pulumi:"privateIpAddress"`
	// The allocation method for the Private IP Address used by this Load Balancer.
	PrivateIpAddressAllocation string `pulumi:"privateIpAddressAllocation"`
	// The Private IP Address Version, either `IPv4` or `IPv6`.
	PrivateIpAddressVersion string `pulumi:"privateIpAddressVersion"`
	// The ID of a  Public IP Address which is associated with this Load Balancer.
	PublicIpAddressId string `pulumi:"publicIpAddressId"`
	// The ID of the Subnet which is associated with the IP Configuration.
	SubnetId string `pulumi:"subnetId"`
	// A list of Availability Zones which the Load Balancer's IP Addresses should be created in.
	Zones []string `pulumi:"zones"`
}

type GetLBFrontendIpConfigurationArgs 

type GetLBFrontendIpConfigurationArgs struct {
	// The id of the Frontend IP Configuration.
	Id pulumi.StringInput `pulumi:"id"`
	// Specifies the name of the Load Balancer.
	Name pulumi.StringInput `pulumi:"name"`
	// Private IP Address to assign to the Load Balancer.
	PrivateIpAddress pulumi.StringInput `pulumi:"privateIpAddress"`
	// The allocation method for the Private IP Address used by this Load Balancer.
	PrivateIpAddressAllocation pulumi.StringInput `pulumi:"privateIpAddressAllocation"`
	// The Private IP Address Version, either `IPv4` or `IPv6`.
	PrivateIpAddressVersion pulumi.StringInput `pulumi:"privateIpAddressVersion"`
	// The ID of a  Public IP Address which is associated with this Load Balancer.
	PublicIpAddressId pulumi.StringInput `pulumi:"publicIpAddressId"`
	// The ID of the Subnet which is associated with the IP Configuration.
	SubnetId pulumi.StringInput `pulumi:"subnetId"`
	// A list of Availability Zones which the Load Balancer's IP Addresses should be created in.
	Zones pulumi.StringArrayInput `pulumi:"zones"`
}

func (GetLBFrontendIpConfigurationArgs) ElementType 

func (GetLBFrontendIpConfigurationArgs) ElementType() reflect.Type

func (GetLBFrontendIpConfigurationArgs) ToGetLBFrontendIpConfigurationOutput 

func (i GetLBFrontendIpConfigurationArgs) ToGetLBFrontendIpConfigurationOutput() GetLBFrontendIpConfigurationOutput

func (GetLBFrontendIpConfigurationArgs) ToGetLBFrontendIpConfigurationOutputWithContext 

func (i GetLBFrontendIpConfigurationArgs) ToGetLBFrontendIpConfigurationOutputWithContext(ctx context.Context) GetLBFrontendIpConfigurationOutput

type GetLBFrontendIpConfigurationArray 

type GetLBFrontendIpConfigurationArray []GetLBFrontendIpConfigurationInput

func (GetLBFrontendIpConfigurationArray) ElementType 

func (GetLBFrontendIpConfigurationArray) ElementType() reflect.Type

func (GetLBFrontendIpConfigurationArray) ToGetLBFrontendIpConfigurationArrayOutput 

func (i GetLBFrontendIpConfigurationArray) ToGetLBFrontendIpConfigurationArrayOutput() GetLBFrontendIpConfigurationArrayOutput

func (GetLBFrontendIpConfigurationArray) ToGetLBFrontendIpConfigurationArrayOutputWithContext 

func (i GetLBFrontendIpConfigurationArray) ToGetLBFrontendIpConfigurationArrayOutputWithContext(ctx context.Context) GetLBFrontendIpConfigurationArrayOutput

type GetLBFrontendIpConfigurationArrayInput 

type GetLBFrontendIpConfigurationArrayInput interface {
	pulumi.Input

	ToGetLBFrontendIpConfigurationArrayOutput() GetLBFrontendIpConfigurationArrayOutput
	ToGetLBFrontendIpConfigurationArrayOutputWithContext(context.Context) GetLBFrontendIpConfigurationArrayOutput
}

GetLBFrontendIpConfigurationArrayInput is an input type that accepts GetLBFrontendIpConfigurationArray and GetLBFrontendIpConfigurationArrayOutput values. You can construct a concrete instance of `GetLBFrontendIpConfigurationArrayInput` via: 

GetLBFrontendIpConfigurationArray{ GetLBFrontendIpConfigurationArgs{...} }

type GetLBFrontendIpConfigurationArrayOutput 

type GetLBFrontendIpConfigurationArrayOutput struct{ *pulumi.OutputState }

func (GetLBFrontendIpConfigurationArrayOutput) ElementType 

func (GetLBFrontendIpConfigurationArrayOutput) ElementType() reflect.Type

func (GetLBFrontendIpConfigurationArrayOutput) Index 

func (o GetLBFrontendIpConfigurationArrayOutput) Index(i pulumi.IntInput) GetLBFrontendIpConfigurationOutput

func (GetLBFrontendIpConfigurationArrayOutput) ToGetLBFrontendIpConfigurationArrayOutput 

func (o GetLBFrontendIpConfigurationArrayOutput) ToGetLBFrontendIpConfigurationArrayOutput() GetLBFrontendIpConfigurationArrayOutput

func (GetLBFrontendIpConfigurationArrayOutput) ToGetLBFrontendIpConfigurationArrayOutputWithContext 

func (o GetLBFrontendIpConfigurationArrayOutput) ToGetLBFrontendIpConfigurationArrayOutputWithContext(ctx context.Context) GetLBFrontendIpConfigurationArrayOutput

type GetLBFrontendIpConfigurationInput 

type GetLBFrontendIpConfigurationInput interface {
	pulumi.Input

	ToGetLBFrontendIpConfigurationOutput() GetLBFrontendIpConfigurationOutput
	ToGetLBFrontendIpConfigurationOutputWithContext(context.Context) GetLBFrontendIpConfigurationOutput
}

GetLBFrontendIpConfigurationInput is an input type that accepts GetLBFrontendIpConfigurationArgs and GetLBFrontendIpConfigurationOutput values. You can construct a concrete instance of `GetLBFrontendIpConfigurationInput` via: 

GetLBFrontendIpConfigurationArgs{...}

type GetLBFrontendIpConfigurationOutput 

type GetLBFrontendIpConfigurationOutput struct{ *pulumi.OutputState }

func (GetLBFrontendIpConfigurationOutput) ElementType 

func (GetLBFrontendIpConfigurationOutput) ElementType() reflect.Type

func (GetLBFrontendIpConfigurationOutput) Id 

func (o GetLBFrontendIpConfigurationOutput) Id() pulumi.StringOutput

The id of the Frontend IP Configuration.

func (GetLBFrontendIpConfigurationOutput) Name 

func (o GetLBFrontendIpConfigurationOutput) Name() pulumi.StringOutput

Specifies the name of the Load Balancer.

func (GetLBFrontendIpConfigurationOutput) PrivateIpAddress 

func (o GetLBFrontendIpConfigurationOutput) PrivateIpAddress() pulumi.StringOutput

Private IP Address to assign to the Load Balancer.

func (GetLBFrontendIpConfigurationOutput) PrivateIpAddressAllocation 

func (o GetLBFrontendIpConfigurationOutput) PrivateIpAddressAllocation() pulumi.StringOutput

The allocation method for the Private IP Address used by this Load Balancer.

func (GetLBFrontendIpConfigurationOutput) PrivateIpAddressVersion 

func (o GetLBFrontendIpConfigurationOutput) PrivateIpAddressVersion() pulumi.StringOutput

The Private IP Address Version, either `IPv4` or `IPv6`.

func (GetLBFrontendIpConfigurationOutput) PublicIpAddressId 

func (o GetLBFrontendIpConfigurationOutput) PublicIpAddressId() pulumi.StringOutput

The ID of a Public IP Address which is associated with this Load Balancer.

func (GetLBFrontendIpConfigurationOutput) SubnetId 

func (o GetLBFrontendIpConfigurationOutput) SubnetId() pulumi.StringOutput

The ID of the Subnet which is associated with the IP Configuration.

func (GetLBFrontendIpConfigurationOutput) ToGetLBFrontendIpConfigurationOutput 

func (o GetLBFrontendIpConfigurationOutput) ToGetLBFrontendIpConfigurationOutput() GetLBFrontendIpConfigurationOutput

func (GetLBFrontendIpConfigurationOutput) ToGetLBFrontendIpConfigurationOutputWithContext 

func (o GetLBFrontendIpConfigurationOutput) ToGetLBFrontendIpConfigurationOutputWithContext(ctx context.Context) GetLBFrontendIpConfigurationOutput

func (GetLBFrontendIpConfigurationOutput) Zones 

func (o GetLBFrontendIpConfigurationOutput) Zones() pulumi.StringArrayOutput

A list of Availability Zones which the Load Balancer's IP Addresses should be created in.

type GetLBResult 

type GetLBResult struct {
	// A `frontendIpConfiguration` block as documented below.
	FrontendIpConfigurations []GetLBFrontendIpConfiguration `pulumi:"frontendIpConfigurations"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// The Azure location where the Load Balancer exists.
	Location string `pulumi:"location"`
	// The name of the Frontend IP Configuration.
	Name string `pulumi:"name"`
	// Private IP Address to assign to the Load Balancer.
	PrivateIpAddress string `pulumi:"privateIpAddress"`
	// The list of private IP address assigned to the load balancer in `frontendIpConfiguration` blocks, if any.
	PrivateIpAddresses []string `pulumi:"privateIpAddresses"`
	ResourceGroupName  string   `pulumi:"resourceGroupName"`
	// The SKU of the Load Balancer.
	Sku string `pulumi:"sku"`
	// A mapping of tags assigned to the resource.
	Tags map[string]string `pulumi:"tags"`
}

A collection of values returned by getLB.

func GetLB 

func GetLB(ctx *pulumi.Context, args *GetLBArgs, opts ...pulumi.InvokeOption) (*GetLBResult, error)

Use this data source to access information about an existing Load Balancer

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/lb"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := lb.GetLB(ctx, &lb.GetLBArgs{
			Name:              "example-lb",
			ResourceGroupName: "example-resources",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("loadbalancerId", example.Id)
		return nil
	})
}

```

type GetLBRuleArgs 

type GetLBRuleArgs struct {
	// The ID of the Load Balancer Rule.
	LoadbalancerId string `pulumi:"loadbalancerId"`
	// The name of this Load Balancer Rule.
	Name string `pulumi:"name"`
	// The name of the Resource Group where the Load Balancer Rule exists.
	ResourceGroupName string `pulumi:"resourceGroupName"`
}

A collection of arguments for invoking getLBRule.

type GetLBRuleResult 

type GetLBRuleResult struct {
	// A reference to a Backend Address Pool over which this Load Balancing Rule operates.
	BackendAddressPoolId string `pulumi:"backendAddressPoolId"`
	// The port used for internal connections on the endpoint.
	BackendPort int `pulumi:"backendPort"`
	// If outbound SNAT is enabled for this Load Balancer Rule.
	DisableOutboundSnat bool `pulumi:"disableOutboundSnat"`
	// If Floating IPs are enabled for this Load Balancer Rule
	EnableFloatingIp bool `pulumi:"enableFloatingIp"`
	// If TCP Reset is enabled for this Load Balancer Rule.
	EnableTcpReset bool `pulumi:"enableTcpReset"`
	// The name of the frontend IP configuration to which the rule is associated.
	FrontendIpConfigurationName string `pulumi:"frontendIpConfigurationName"`
	// The port for the external endpoint.
	FrontendPort int `pulumi:"frontendPort"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// Specifies the idle timeout in minutes for TCP connections.
	IdleTimeoutInMinutes int `pulumi:"idleTimeoutInMinutes"`
	// Specifies the load balancing distribution type used by the Load Balancer.
	LoadDistribution string `pulumi:"loadDistribution"`
	LoadbalancerId   string `pulumi:"loadbalancerId"`
	Name             string `pulumi:"name"`
	// A reference to a Probe used by this Load Balancing Rule.
	ProbeId string `pulumi:"probeId"`
	// The transport protocol for the external endpoint.
	Protocol          string `pulumi:"protocol"`
	ResourceGroupName string `pulumi:"resourceGroupName"`
}

A collection of values returned by getLBRule.

func GetLBRule 

func GetLBRule(ctx *pulumi.Context, args *GetLBRuleArgs, opts ...pulumi.InvokeOption) (*GetLBRuleResult, error)

Use this data source to access information about an existing Load Balancer Rule.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/lb"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleLB, err := lb.GetLB(ctx, &lb.GetLBArgs{
			Name:              "example-lb",
			ResourceGroupName: "example-resources",
		}, nil)
		if err != nil {
			return err
		}
		exampleLBRule, err := lb.GetLBRule(ctx, &lb.GetLBRuleArgs{
			Name:              "first",
			ResourceGroupName: "example-resources",
			LoadbalancerId:    exampleLB.Id,
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("lbRuleId", exampleLBRule.Id)
		return nil
	})
}

```

type LoadBalancer 

type LoadBalancer struct {
	pulumi.CustomResourceState

	// One or multiple `frontendIpConfiguration` blocks as documented below.
	FrontendIpConfigurations LoadBalancerFrontendIpConfigurationArrayOutput `pulumi:"frontendIpConfigurations"`
	// Specifies the supported Azure Region where the Load Balancer should be created.
	Location pulumi.StringOutput `pulumi:"location"`
	// Specifies the name of the Load Balancer.
	Name pulumi.StringOutput `pulumi:"name"`
	// Private IP Address to assign to the Load Balancer. The last one and first four IPs in any range are reserved and cannot be manually assigned.
	PrivateIpAddress pulumi.StringOutput `pulumi:"privateIpAddress"`
	// The list of private IP address assigned to the load balancer in `frontendIpConfiguration` blocks, if any.
	PrivateIpAddresses pulumi.StringArrayOutput `pulumi:"privateIpAddresses"`
	// The name of the Resource Group in which to create the Load Balancer.
	ResourceGroupName pulumi.StringOutput `pulumi:"resourceGroupName"`
	// The SKU of the Azure Load Balancer. Accepted values are `Basic` and `Standard`. Defaults to `Basic`.
	Sku pulumi.StringPtrOutput `pulumi:"sku"`
	// A mapping of tags to assign to the resource.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
}

Manages a Load Balancer Resource.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/lb"
"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/network"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		examplePublicIp, err := network.NewPublicIp(ctx, "examplePublicIp", &network.PublicIpArgs{
			Location:          pulumi.String("West US"),
			ResourceGroupName: exampleResourceGroup.Name,
			AllocationMethod:  pulumi.String("Static"),
		})
		if err != nil {
			return err
		}
		_, err = lb.NewLoadBalancer(ctx, "exampleLoadBalancer", &lb.LoadBalancerArgs{
			Location:          pulumi.String("West US"),
			ResourceGroupName: exampleResourceGroup.Name,
			FrontendIpConfigurations: lb.LoadBalancerFrontendIpConfigurationArray{
				&lb.LoadBalancerFrontendIpConfigurationArgs{
					Name:              pulumi.String("PublicIPAddress"),
					PublicIpAddressId: examplePublicIp.ID(),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Load Balancers can be imported using the `resource id`, e.g.

```sh 

$ pulumi import azure:lb/loadBalancer:LoadBalancer example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.Network/loadBalancers/lb1

```

func GetLoadBalancer 

func GetLoadBalancer(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *LoadBalancerState, opts ...pulumi.ResourceOption) (*LoadBalancer, error)

GetLoadBalancer gets an existing LoadBalancer 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 NewLoadBalancer 

func NewLoadBalancer(ctx *pulumi.Context,
	name string, args *LoadBalancerArgs, opts ...pulumi.ResourceOption) (*LoadBalancer, error)

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

func (*LoadBalancer) ElementType 

func (*LoadBalancer) ElementType() reflect.Type

func (*LoadBalancer) ToLoadBalancerOutput 

func (i *LoadBalancer) ToLoadBalancerOutput() LoadBalancerOutput

func (*LoadBalancer) ToLoadBalancerOutputWithContext 

func (i *LoadBalancer) ToLoadBalancerOutputWithContext(ctx context.Context) LoadBalancerOutput

func (*LoadBalancer) ToLoadBalancerPtrOutput 

func (i *LoadBalancer) ToLoadBalancerPtrOutput() LoadBalancerPtrOutput

func (*LoadBalancer) ToLoadBalancerPtrOutputWithContext 

func (i *LoadBalancer) ToLoadBalancerPtrOutputWithContext(ctx context.Context) LoadBalancerPtrOutput

type LoadBalancerArgs 

type LoadBalancerArgs struct {
	// One or multiple `frontendIpConfiguration` blocks as documented below.
	FrontendIpConfigurations LoadBalancerFrontendIpConfigurationArrayInput
	// Specifies the supported Azure Region where the Load Balancer should be created.
	Location pulumi.StringPtrInput
	// Specifies the name of the Load Balancer.
	Name pulumi.StringPtrInput
	// The name of the Resource Group in which to create the Load Balancer.
	ResourceGroupName pulumi.StringInput
	// The SKU of the Azure Load Balancer. Accepted values are `Basic` and `Standard`. Defaults to `Basic`.
	Sku pulumi.StringPtrInput
	// A mapping of tags to assign to the resource.
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a LoadBalancer resource.

func (LoadBalancerArgs) ElementType 

func (LoadBalancerArgs) ElementType() reflect.Type

type LoadBalancerArray 

type LoadBalancerArray []LoadBalancerInput

func (LoadBalancerArray) ElementType 

func (LoadBalancerArray) ElementType() reflect.Type

func (LoadBalancerArray) ToLoadBalancerArrayOutput 

func (i LoadBalancerArray) ToLoadBalancerArrayOutput() LoadBalancerArrayOutput

func (LoadBalancerArray) ToLoadBalancerArrayOutputWithContext 

func (i LoadBalancerArray) ToLoadBalancerArrayOutputWithContext(ctx context.Context) LoadBalancerArrayOutput

type LoadBalancerArrayInput 

type LoadBalancerArrayInput interface {
	pulumi.Input

	ToLoadBalancerArrayOutput() LoadBalancerArrayOutput
	ToLoadBalancerArrayOutputWithContext(context.Context) LoadBalancerArrayOutput
}

LoadBalancerArrayInput is an input type that accepts LoadBalancerArray and LoadBalancerArrayOutput values. You can construct a concrete instance of `LoadBalancerArrayInput` via: 

LoadBalancerArray{ LoadBalancerArgs{...} }

type LoadBalancerArrayOutput 

type LoadBalancerArrayOutput struct{ *pulumi.OutputState }

func (LoadBalancerArrayOutput) ElementType 

func (LoadBalancerArrayOutput) ElementType() reflect.Type

func (LoadBalancerArrayOutput) Index 

func (o LoadBalancerArrayOutput) Index(i pulumi.IntInput) LoadBalancerOutput

func (LoadBalancerArrayOutput) ToLoadBalancerArrayOutput 

func (o LoadBalancerArrayOutput) ToLoadBalancerArrayOutput() LoadBalancerArrayOutput

func (LoadBalancerArrayOutput) ToLoadBalancerArrayOutputWithContext 

func (o LoadBalancerArrayOutput) ToLoadBalancerArrayOutputWithContext(ctx context.Context) LoadBalancerArrayOutput

type LoadBalancerFrontendIpConfiguration 

type LoadBalancerFrontendIpConfiguration struct {
	// A list of Availability Zones which the Load Balancer's IP Addresses should be created in. Possible values are `Zone-Redundant`, `1`, `2`, `3`, and `No-Zone`. Availability Zone can only be updated whenever the name of the front end ip configuration changes. Defaults to `Zone-Redundant`.
	// `No-Zones` - A `non-zonal` resource will be created and the resource will not be replicated or distributed to any Availability Zones.
	AvailabilityZone *string `pulumi:"availabilityZone"`
	// The id of the Frontend IP Configuration.
	Id *string `pulumi:"id"`
	// The list of IDs of inbound rules that use this frontend IP.
	InboundNatRules []string `pulumi:"inboundNatRules"`
	// The list of IDs of load balancing rules that use this frontend IP.
	LoadBalancerRules []string `pulumi:"loadBalancerRules"`
	// Specifies the name of the frontend ip configuration.
	Name string `pulumi:"name"`
	// The list of IDs outbound rules that use this frontend IP.
	OutboundRules []string `pulumi:"outboundRules"`
	// Private IP Address to assign to the Load Balancer. The last one and first four IPs in any range are reserved and cannot be manually assigned.
	PrivateIpAddress *string `pulumi:"privateIpAddress"`
	// The allocation method for the Private IP Address used by this Load Balancer. Possible values as `Dynamic` and `Static`.
	PrivateIpAddressAllocation *string `pulumi:"privateIpAddressAllocation"`
	// The version of IP that the Private IP Address is. Possible values are `IPv4` or `IPv6`.
	PrivateIpAddressVersion *string `pulumi:"privateIpAddressVersion"`
	// The ID of a Public IP Address which should be associated with the Load Balancer.
	PublicIpAddressId *string `pulumi:"publicIpAddressId"`
	// The ID of a Public IP Prefix which should be associated with the Load Balancer. Public IP Prefix can only be used with outbound rules.
	PublicIpPrefixId *string `pulumi:"publicIpPrefixId"`
	// The ID of the Subnet which should be associated with the IP Configuration.
	SubnetId *string `pulumi:"subnetId"`
	// Deprecated: This property has been deprecated in favour of `availability_zone` due to a breaking behavioural change in Azure: https://azure.microsoft.com/en-us/updates/zone-behavior-change/
	Zones *string `pulumi:"zones"`
}

type LoadBalancerFrontendIpConfigurationArgs 

type LoadBalancerFrontendIpConfigurationArgs struct {
	// A list of Availability Zones which the Load Balancer's IP Addresses should be created in. Possible values are `Zone-Redundant`, `1`, `2`, `3`, and `No-Zone`. Availability Zone can only be updated whenever the name of the front end ip configuration changes. Defaults to `Zone-Redundant`.
	// `No-Zones` - A `non-zonal` resource will be created and the resource will not be replicated or distributed to any Availability Zones.
	AvailabilityZone pulumi.StringPtrInput `pulumi:"availabilityZone"`
	// The id of the Frontend IP Configuration.
	Id pulumi.StringPtrInput `pulumi:"id"`
	// The list of IDs of inbound rules that use this frontend IP.
	InboundNatRules pulumi.StringArrayInput `pulumi:"inboundNatRules"`
	// The list of IDs of load balancing rules that use this frontend IP.
	LoadBalancerRules pulumi.StringArrayInput `pulumi:"loadBalancerRules"`
	// Specifies the name of the frontend ip configuration.
	Name pulumi.StringInput `pulumi:"name"`
	// The list of IDs outbound rules that use this frontend IP.
	OutboundRules pulumi.StringArrayInput `pulumi:"outboundRules"`
	// Private IP Address to assign to the Load Balancer. The last one and first four IPs in any range are reserved and cannot be manually assigned.
	PrivateIpAddress pulumi.StringPtrInput `pulumi:"privateIpAddress"`
	// The allocation method for the Private IP Address used by this Load Balancer. Possible values as `Dynamic` and `Static`.
	PrivateIpAddressAllocation pulumi.StringPtrInput `pulumi:"privateIpAddressAllocation"`
	// The version of IP that the Private IP Address is. Possible values are `IPv4` or `IPv6`.
	PrivateIpAddressVersion pulumi.StringPtrInput `pulumi:"privateIpAddressVersion"`
	// The ID of a Public IP Address which should be associated with the Load Balancer.
	PublicIpAddressId pulumi.StringPtrInput `pulumi:"publicIpAddressId"`
	// The ID of a Public IP Prefix which should be associated with the Load Balancer. Public IP Prefix can only be used with outbound rules.
	PublicIpPrefixId pulumi.StringPtrInput `pulumi:"publicIpPrefixId"`
	// The ID of the Subnet which should be associated with the IP Configuration.
	SubnetId pulumi.StringPtrInput `pulumi:"subnetId"`
	// Deprecated: This property has been deprecated in favour of `availability_zone` due to a breaking behavioural change in Azure: https://azure.microsoft.com/en-us/updates/zone-behavior-change/
	Zones pulumi.StringPtrInput `pulumi:"zones"`
}

func (LoadBalancerFrontendIpConfigurationArgs) ElementType 

func (LoadBalancerFrontendIpConfigurationArgs) ElementType() reflect.Type

func (LoadBalancerFrontendIpConfigurationArgs) ToLoadBalancerFrontendIpConfigurationOutput 

func (i LoadBalancerFrontendIpConfigurationArgs) ToLoadBalancerFrontendIpConfigurationOutput() LoadBalancerFrontendIpConfigurationOutput

func (LoadBalancerFrontendIpConfigurationArgs) ToLoadBalancerFrontendIpConfigurationOutputWithContext 

func (i LoadBalancerFrontendIpConfigurationArgs) ToLoadBalancerFrontendIpConfigurationOutputWithContext(ctx context.Context) LoadBalancerFrontendIpConfigurationOutput

type LoadBalancerFrontendIpConfigurationArray 

type LoadBalancerFrontendIpConfigurationArray []LoadBalancerFrontendIpConfigurationInput

func (LoadBalancerFrontendIpConfigurationArray) ElementType 

func (LoadBalancerFrontendIpConfigurationArray) ElementType() reflect.Type

func (LoadBalancerFrontendIpConfigurationArray) ToLoadBalancerFrontendIpConfigurationArrayOutput 

func (i LoadBalancerFrontendIpConfigurationArray) ToLoadBalancerFrontendIpConfigurationArrayOutput() LoadBalancerFrontendIpConfigurationArrayOutput

func (LoadBalancerFrontendIpConfigurationArray) ToLoadBalancerFrontendIpConfigurationArrayOutputWithContext 

func (i LoadBalancerFrontendIpConfigurationArray) ToLoadBalancerFrontendIpConfigurationArrayOutputWithContext(ctx context.Context) LoadBalancerFrontendIpConfigurationArrayOutput

type LoadBalancerFrontendIpConfigurationArrayInput 

type LoadBalancerFrontendIpConfigurationArrayInput interface {
	pulumi.Input

	ToLoadBalancerFrontendIpConfigurationArrayOutput() LoadBalancerFrontendIpConfigurationArrayOutput
	ToLoadBalancerFrontendIpConfigurationArrayOutputWithContext(context.Context) LoadBalancerFrontendIpConfigurationArrayOutput
}

LoadBalancerFrontendIpConfigurationArrayInput is an input type that accepts LoadBalancerFrontendIpConfigurationArray and LoadBalancerFrontendIpConfigurationArrayOutput values. You can construct a concrete instance of `LoadBalancerFrontendIpConfigurationArrayInput` via: 

LoadBalancerFrontendIpConfigurationArray{ LoadBalancerFrontendIpConfigurationArgs{...} }

type LoadBalancerFrontendIpConfigurationArrayOutput 

type LoadBalancerFrontendIpConfigurationArrayOutput struct{ *pulumi.OutputState }

func (LoadBalancerFrontendIpConfigurationArrayOutput) ElementType 

func (LoadBalancerFrontendIpConfigurationArrayOutput) ElementType() reflect.Type

func (LoadBalancerFrontendIpConfigurationArrayOutput) Index 

func (o LoadBalancerFrontendIpConfigurationArrayOutput) Index(i pulumi.IntInput) LoadBalancerFrontendIpConfigurationOutput

func (LoadBalancerFrontendIpConfigurationArrayOutput) ToLoadBalancerFrontendIpConfigurationArrayOutput 

func (o LoadBalancerFrontendIpConfigurationArrayOutput) ToLoadBalancerFrontendIpConfigurationArrayOutput() LoadBalancerFrontendIpConfigurationArrayOutput

func (LoadBalancerFrontendIpConfigurationArrayOutput) ToLoadBalancerFrontendIpConfigurationArrayOutputWithContext 

func (o LoadBalancerFrontendIpConfigurationArrayOutput) ToLoadBalancerFrontendIpConfigurationArrayOutputWithContext(ctx context.Context) LoadBalancerFrontendIpConfigurationArrayOutput

type LoadBalancerFrontendIpConfigurationInput 

type LoadBalancerFrontendIpConfigurationInput interface {
	pulumi.Input

	ToLoadBalancerFrontendIpConfigurationOutput() LoadBalancerFrontendIpConfigurationOutput
	ToLoadBalancerFrontendIpConfigurationOutputWithContext(context.Context) LoadBalancerFrontendIpConfigurationOutput
}

LoadBalancerFrontendIpConfigurationInput is an input type that accepts LoadBalancerFrontendIpConfigurationArgs and LoadBalancerFrontendIpConfigurationOutput values. You can construct a concrete instance of `LoadBalancerFrontendIpConfigurationInput` via: 

LoadBalancerFrontendIpConfigurationArgs{...}

type LoadBalancerFrontendIpConfigurationOutput 

type LoadBalancerFrontendIpConfigurationOutput struct{ *pulumi.OutputState }

func (LoadBalancerFrontendIpConfigurationOutput) AvailabilityZone added in v4.8.0 

func (o LoadBalancerFrontendIpConfigurationOutput) AvailabilityZone() pulumi.StringPtrOutput

A list of Availability Zones which the Load Balancer's IP Addresses should be created in. Possible values are `Zone-Redundant`, `1`, `2`, `3`, and `No-Zone`. Availability Zone can only be updated whenever the name of the front end ip configuration changes. Defaults to `Zone-Redundant`. `No-Zones` - A `non-zonal` resource will be created and the resource will not be replicated or distributed to any Availability Zones.

func (LoadBalancerFrontendIpConfigurationOutput) ElementType 

func (LoadBalancerFrontendIpConfigurationOutput) ElementType() reflect.Type

func (LoadBalancerFrontendIpConfigurationOutput) Id 

func (o LoadBalancerFrontendIpConfigurationOutput) Id() pulumi.StringPtrOutput

The id of the Frontend IP Configuration.

func (LoadBalancerFrontendIpConfigurationOutput) InboundNatRules 

func (o LoadBalancerFrontendIpConfigurationOutput) InboundNatRules() pulumi.StringArrayOutput

The list of IDs of inbound rules that use this frontend IP.

func (LoadBalancerFrontendIpConfigurationOutput) LoadBalancerRules 

func (o LoadBalancerFrontendIpConfigurationOutput) LoadBalancerRules() pulumi.StringArrayOutput

The list of IDs of load balancing rules that use this frontend IP.

func (LoadBalancerFrontendIpConfigurationOutput) Name 

func (o LoadBalancerFrontendIpConfigurationOutput) Name() pulumi.StringOutput

Specifies the name of the frontend ip configuration.

func (LoadBalancerFrontendIpConfigurationOutput) OutboundRules 

func (o LoadBalancerFrontendIpConfigurationOutput) OutboundRules() pulumi.StringArrayOutput

The list of IDs outbound rules that use this frontend IP.

func (LoadBalancerFrontendIpConfigurationOutput) PrivateIpAddress 

func (o LoadBalancerFrontendIpConfigurationOutput) PrivateIpAddress() pulumi.StringPtrOutput

Private IP Address to assign to the Load Balancer. The last one and first four IPs in any range are reserved and cannot be manually assigned.

func (LoadBalancerFrontendIpConfigurationOutput) PrivateIpAddressAllocation 

func (o LoadBalancerFrontendIpConfigurationOutput) PrivateIpAddressAllocation() pulumi.StringPtrOutput

The allocation method for the Private IP Address used by this Load Balancer. Possible values as `Dynamic` and `Static`.

func (LoadBalancerFrontendIpConfigurationOutput) PrivateIpAddressVersion 

func (o LoadBalancerFrontendIpConfigurationOutput) PrivateIpAddressVersion() pulumi.StringPtrOutput

The version of IP that the Private IP Address is. Possible values are `IPv4` or `IPv6`.

func (LoadBalancerFrontendIpConfigurationOutput) PublicIpAddressId 

func (o LoadBalancerFrontendIpConfigurationOutput) PublicIpAddressId() pulumi.StringPtrOutput

The ID of a Public IP Address which should be associated with the Load Balancer.

func (LoadBalancerFrontendIpConfigurationOutput) PublicIpPrefixId 

func (o LoadBalancerFrontendIpConfigurationOutput) PublicIpPrefixId() pulumi.StringPtrOutput

The ID of a Public IP Prefix which should be associated with the Load Balancer. Public IP Prefix can only be used with outbound rules.

func (LoadBalancerFrontendIpConfigurationOutput) SubnetId 

func (o LoadBalancerFrontendIpConfigurationOutput) SubnetId() pulumi.StringPtrOutput

The ID of the Subnet which should be associated with the IP Configuration.

func (LoadBalancerFrontendIpConfigurationOutput) ToLoadBalancerFrontendIpConfigurationOutput 

func (o LoadBalancerFrontendIpConfigurationOutput) ToLoadBalancerFrontendIpConfigurationOutput() LoadBalancerFrontendIpConfigurationOutput

func (LoadBalancerFrontendIpConfigurationOutput) ToLoadBalancerFrontendIpConfigurationOutputWithContext 

func (o LoadBalancerFrontendIpConfigurationOutput) ToLoadBalancerFrontendIpConfigurationOutputWithContext(ctx context.Context) LoadBalancerFrontendIpConfigurationOutput

func (LoadBalancerFrontendIpConfigurationOutput) Zones deprecated 

func (o LoadBalancerFrontendIpConfigurationOutput) Zones() pulumi.StringPtrOutput

Deprecated: This property has been deprecated in favour of `availability_zone` due to a breaking behavioural change in Azure: https://azure.microsoft.com/en-us/updates/zone-behavior-change/

type LoadBalancerInput 

type LoadBalancerInput interface {
	pulumi.Input

	ToLoadBalancerOutput() LoadBalancerOutput
	ToLoadBalancerOutputWithContext(ctx context.Context) LoadBalancerOutput
}

type LoadBalancerMap 

type LoadBalancerMap map[string]LoadBalancerInput

func (LoadBalancerMap) ElementType 

func (LoadBalancerMap) ElementType() reflect.Type

func (LoadBalancerMap) ToLoadBalancerMapOutput 

func (i LoadBalancerMap) ToLoadBalancerMapOutput() LoadBalancerMapOutput

func (LoadBalancerMap) ToLoadBalancerMapOutputWithContext 

func (i LoadBalancerMap) ToLoadBalancerMapOutputWithContext(ctx context.Context) LoadBalancerMapOutput

type LoadBalancerMapInput 

type LoadBalancerMapInput interface {
	pulumi.Input

	ToLoadBalancerMapOutput() LoadBalancerMapOutput
	ToLoadBalancerMapOutputWithContext(context.Context) LoadBalancerMapOutput
}

LoadBalancerMapInput is an input type that accepts LoadBalancerMap and LoadBalancerMapOutput values. You can construct a concrete instance of `LoadBalancerMapInput` via: 

LoadBalancerMap{ "key": LoadBalancerArgs{...} }

type LoadBalancerMapOutput 

type LoadBalancerMapOutput struct{ *pulumi.OutputState }

func (LoadBalancerMapOutput) ElementType 

func (LoadBalancerMapOutput) ElementType() reflect.Type

func (LoadBalancerMapOutput) MapIndex 

func (o LoadBalancerMapOutput) MapIndex(k pulumi.StringInput) LoadBalancerOutput

func (LoadBalancerMapOutput) ToLoadBalancerMapOutput 

func (o LoadBalancerMapOutput) ToLoadBalancerMapOutput() LoadBalancerMapOutput

func (LoadBalancerMapOutput) ToLoadBalancerMapOutputWithContext 

func (o LoadBalancerMapOutput) ToLoadBalancerMapOutputWithContext(ctx context.Context) LoadBalancerMapOutput

type LoadBalancerOutput 

type LoadBalancerOutput struct {
	*pulumi.OutputState
}

func (LoadBalancerOutput) ElementType 

func (LoadBalancerOutput) ElementType() reflect.Type

func (LoadBalancerOutput) ToLoadBalancerOutput 

func (o LoadBalancerOutput) ToLoadBalancerOutput() LoadBalancerOutput

func (LoadBalancerOutput) ToLoadBalancerOutputWithContext 

func (o LoadBalancerOutput) ToLoadBalancerOutputWithContext(ctx context.Context) LoadBalancerOutput

func (LoadBalancerOutput) ToLoadBalancerPtrOutput 

func (o LoadBalancerOutput) ToLoadBalancerPtrOutput() LoadBalancerPtrOutput

func (LoadBalancerOutput) ToLoadBalancerPtrOutputWithContext 

func (o LoadBalancerOutput) ToLoadBalancerPtrOutputWithContext(ctx context.Context) LoadBalancerPtrOutput

type LoadBalancerPtrInput 

type LoadBalancerPtrInput interface {
	pulumi.Input

	ToLoadBalancerPtrOutput() LoadBalancerPtrOutput
	ToLoadBalancerPtrOutputWithContext(ctx context.Context) LoadBalancerPtrOutput
}

type LoadBalancerPtrOutput 

type LoadBalancerPtrOutput struct {
	*pulumi.OutputState
}

func (LoadBalancerPtrOutput) ElementType 

func (LoadBalancerPtrOutput) ElementType() reflect.Type

func (LoadBalancerPtrOutput) ToLoadBalancerPtrOutput 

func (o LoadBalancerPtrOutput) ToLoadBalancerPtrOutput() LoadBalancerPtrOutput

func (LoadBalancerPtrOutput) ToLoadBalancerPtrOutputWithContext 

func (o LoadBalancerPtrOutput) ToLoadBalancerPtrOutputWithContext(ctx context.Context) LoadBalancerPtrOutput

type LoadBalancerState 

type LoadBalancerState struct {
	// One or multiple `frontendIpConfiguration` blocks as documented below.
	FrontendIpConfigurations LoadBalancerFrontendIpConfigurationArrayInput
	// Specifies the supported Azure Region where the Load Balancer should be created.
	Location pulumi.StringPtrInput
	// Specifies the name of the Load Balancer.
	Name pulumi.StringPtrInput
	// Private IP Address to assign to the Load Balancer. The last one and first four IPs in any range are reserved and cannot be manually assigned.
	PrivateIpAddress pulumi.StringPtrInput
	// The list of private IP address assigned to the load balancer in `frontendIpConfiguration` blocks, if any.
	PrivateIpAddresses pulumi.StringArrayInput
	// The name of the Resource Group in which to create the Load Balancer.
	ResourceGroupName pulumi.StringPtrInput
	// The SKU of the Azure Load Balancer. Accepted values are `Basic` and `Standard`. Defaults to `Basic`.
	Sku pulumi.StringPtrInput
	// A mapping of tags to assign to the resource.
	Tags pulumi.StringMapInput
}

func (LoadBalancerState) ElementType 

func (LoadBalancerState) ElementType() reflect.Type

type LookupBackendAddressPoolArgs 

type LookupBackendAddressPoolArgs struct {
	// The ID of the Load Balancer in which the Backend Address Pool exists.
	LoadbalancerId string `pulumi:"loadbalancerId"`
	// Specifies the name of the Backend Address Pool.
	Name string `pulumi:"name"`
}

A collection of arguments for invoking getBackendAddressPool.

type LookupBackendAddressPoolResult 

type LookupBackendAddressPoolResult struct {
	// A list of `backendAddress` block as defined below.
	BackendAddresses []GetBackendAddressPoolBackendAddress `pulumi:"backendAddresses"`
	// A list of references to IP addresses defined in network interfaces.
	BackendIpConfigurations []GetBackendAddressPoolBackendIpConfiguration `pulumi:"backendIpConfigurations"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// A list of the Load Balancing Rules associated with this Backend Address Pool.
	LoadBalancingRules []string `pulumi:"loadBalancingRules"`
	LoadbalancerId     string   `pulumi:"loadbalancerId"`
	// The name of the Backend Address.
	Name string `pulumi:"name"`
	// A list of the Load Balancing Outbound Rules associated with this Backend Address Pool.
	OutboundRules []string `pulumi:"outboundRules"`
}

A collection of values returned by getBackendAddressPool.

func LookupBackendAddressPool 

func LookupBackendAddressPool(ctx *pulumi.Context, args *LookupBackendAddressPoolArgs, opts ...pulumi.InvokeOption) (*LookupBackendAddressPoolResult, error)

Use this data source to access information about an existing Load Balancer's Backend Address Pool.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/lb"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleLB, err := lb.GetLB(ctx, &lb.GetLBArgs{
			Name:              "example-lb",
			ResourceGroupName: "example-resources",
		}, nil)
		if err != nil {
			return err
		}
		exampleBackendAddressPool, err := lb.LookupBackendAddressPool(ctx, &lb.LookupBackendAddressPoolArgs{
			Name:           "first",
			LoadbalancerId: exampleLB.Id,
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("backendAddressPoolId", exampleBackendAddressPool.Id)
		var splat0 []interface{}
		for _, val0 := range data.Azurerm_lb_backend_address_pool.Beap.Backend_ip_configurations {
			splat0 = append(splat0, val0.Id)
		}
		ctx.Export("backendIpConfigurationIds", splat0)
		return nil
	})
}

```

type NatPool 

type NatPool struct {
	pulumi.CustomResourceState

	// The port used for the internal endpoint. Possible values range between 1 and 65535, inclusive.
	BackendPort               pulumi.IntOutput    `pulumi:"backendPort"`
	FrontendIpConfigurationId pulumi.StringOutput `pulumi:"frontendIpConfigurationId"`
	// The name of the frontend IP configuration exposing this rule.
	FrontendIpConfigurationName pulumi.StringOutput `pulumi:"frontendIpConfigurationName"`
	// The last port number in the range of external ports that will be used to provide Inbound Nat to NICs associated with this Load Balancer. Possible values range between 1 and 65534, inclusive.
	FrontendPortEnd pulumi.IntOutput `pulumi:"frontendPortEnd"`
	// The first port number in the range of external ports that will be used to provide Inbound Nat to NICs associated with this Load Balancer. Possible values range between 1 and 65534, inclusive.
	FrontendPortStart pulumi.IntOutput `pulumi:"frontendPortStart"`
	// The ID of the Load Balancer in which to create the NAT pool.
	LoadbalancerId pulumi.StringOutput `pulumi:"loadbalancerId"`
	// Specifies the name of the NAT pool.
	Name pulumi.StringOutput `pulumi:"name"`
	// The transport protocol for the external endpoint. Possible values are `Udp` or `Tcp`.
	Protocol pulumi.StringOutput `pulumi:"protocol"`
	// The name of the resource group in which to create the resource.
	ResourceGroupName pulumi.StringOutput `pulumi:"resourceGroupName"`
}

Manages a Load Balancer NAT pool.

> **NOTE:** This resource cannot be used with with virtual machines, instead use the `lb.NatRule` resource.

> **NOTE** When using this resource, the Load Balancer needs to have a FrontEnd IP Configuration Attached

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/lb"
"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/network"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		examplePublicIp, err := network.NewPublicIp(ctx, "examplePublicIp", &network.PublicIpArgs{
			Location:          pulumi.String("West US"),
			ResourceGroupName: exampleResourceGroup.Name,
			AllocationMethod:  pulumi.String("Static"),
		})
		if err != nil {
			return err
		}
		exampleLoadBalancer, err := lb.NewLoadBalancer(ctx, "exampleLoadBalancer", &lb.LoadBalancerArgs{
			Location:          pulumi.String("West US"),
			ResourceGroupName: exampleResourceGroup.Name,
			FrontendIpConfigurations: lb.LoadBalancerFrontendIpConfigurationArray{
				&lb.LoadBalancerFrontendIpConfigurationArgs{
					Name:              pulumi.String("PublicIPAddress"),
					PublicIpAddressId: examplePublicIp.ID(),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = lb.NewNatPool(ctx, "exampleNatPool", &lb.NatPoolArgs{
			ResourceGroupName:           exampleResourceGroup.Name,
			LoadbalancerId:              exampleLoadBalancer.ID(),
			Protocol:                    pulumi.String("Tcp"),
			FrontendPortStart:           pulumi.Int(80),
			FrontendPortEnd:             pulumi.Int(81),
			BackendPort:                 pulumi.Int(8080),
			FrontendIpConfigurationName: pulumi.String("PublicIPAddress"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Load Balancer NAT Pools can be imported using the `resource id`, e.g.

```sh 

$ pulumi import azure:lb/natPool:NatPool example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.Network/loadBalancers/lb1/inboundNatPools/pool1

```

func GetNatPool 

func GetNatPool(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *NatPoolState, opts ...pulumi.ResourceOption) (*NatPool, error)

GetNatPool gets an existing NatPool 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 NewNatPool 

func NewNatPool(ctx *pulumi.Context,
	name string, args *NatPoolArgs, opts ...pulumi.ResourceOption) (*NatPool, error)

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

func (*NatPool) ElementType 

func (*NatPool) ElementType() reflect.Type

func (*NatPool) ToNatPoolOutput 

func (i *NatPool) ToNatPoolOutput() NatPoolOutput

func (*NatPool) ToNatPoolOutputWithContext 

func (i *NatPool) ToNatPoolOutputWithContext(ctx context.Context) NatPoolOutput

func (*NatPool) ToNatPoolPtrOutput 

func (i *NatPool) ToNatPoolPtrOutput() NatPoolPtrOutput

func (*NatPool) ToNatPoolPtrOutputWithContext 

func (i *NatPool) ToNatPoolPtrOutputWithContext(ctx context.Context) NatPoolPtrOutput

type NatPoolArgs 

type NatPoolArgs struct {
	// The port used for the internal endpoint. Possible values range between 1 and 65535, inclusive.
	BackendPort pulumi.IntInput
	// The name of the frontend IP configuration exposing this rule.
	FrontendIpConfigurationName pulumi.StringInput
	// The last port number in the range of external ports that will be used to provide Inbound Nat to NICs associated with this Load Balancer. Possible values range between 1 and 65534, inclusive.
	FrontendPortEnd pulumi.IntInput
	// The first port number in the range of external ports that will be used to provide Inbound Nat to NICs associated with this Load Balancer. Possible values range between 1 and 65534, inclusive.
	FrontendPortStart pulumi.IntInput
	// The ID of the Load Balancer in which to create the NAT pool.
	LoadbalancerId pulumi.StringInput
	// Specifies the name of the NAT pool.
	Name pulumi.StringPtrInput
	// The transport protocol for the external endpoint. Possible values are `Udp` or `Tcp`.
	Protocol pulumi.StringInput
	// The name of the resource group in which to create the resource.
	ResourceGroupName pulumi.StringInput
}

The set of arguments for constructing a NatPool resource.

func (NatPoolArgs) ElementType 

func (NatPoolArgs) ElementType() reflect.Type

type NatPoolArray 

type NatPoolArray []NatPoolInput

func (NatPoolArray) ElementType 

func (NatPoolArray) ElementType() reflect.Type

func (NatPoolArray) ToNatPoolArrayOutput 

func (i NatPoolArray) ToNatPoolArrayOutput() NatPoolArrayOutput

func (NatPoolArray) ToNatPoolArrayOutputWithContext 

func (i NatPoolArray) ToNatPoolArrayOutputWithContext(ctx context.Context) NatPoolArrayOutput

type NatPoolArrayInput 

type NatPoolArrayInput interface {
	pulumi.Input

	ToNatPoolArrayOutput() NatPoolArrayOutput
	ToNatPoolArrayOutputWithContext(context.Context) NatPoolArrayOutput
}

NatPoolArrayInput is an input type that accepts NatPoolArray and NatPoolArrayOutput values. You can construct a concrete instance of `NatPoolArrayInput` via: 

NatPoolArray{ NatPoolArgs{...} }

type NatPoolArrayOutput 

type NatPoolArrayOutput struct{ *pulumi.OutputState }

func (NatPoolArrayOutput) ElementType 

func (NatPoolArrayOutput) ElementType() reflect.Type

func (NatPoolArrayOutput) Index 

func (o NatPoolArrayOutput) Index(i pulumi.IntInput) NatPoolOutput

func (NatPoolArrayOutput) ToNatPoolArrayOutput 

func (o NatPoolArrayOutput) ToNatPoolArrayOutput() NatPoolArrayOutput

func (NatPoolArrayOutput) ToNatPoolArrayOutputWithContext 

func (o NatPoolArrayOutput) ToNatPoolArrayOutputWithContext(ctx context.Context) NatPoolArrayOutput

type NatPoolInput 

type NatPoolInput interface {
	pulumi.Input

	ToNatPoolOutput() NatPoolOutput
	ToNatPoolOutputWithContext(ctx context.Context) NatPoolOutput
}

type NatPoolMap 

type NatPoolMap map[string]NatPoolInput

func (NatPoolMap) ElementType 

func (NatPoolMap) ElementType() reflect.Type

func (NatPoolMap) ToNatPoolMapOutput 

func (i NatPoolMap) ToNatPoolMapOutput() NatPoolMapOutput

func (NatPoolMap) ToNatPoolMapOutputWithContext 

func (i NatPoolMap) ToNatPoolMapOutputWithContext(ctx context.Context) NatPoolMapOutput

type NatPoolMapInput 

type NatPoolMapInput interface {
	pulumi.Input

	ToNatPoolMapOutput() NatPoolMapOutput
	ToNatPoolMapOutputWithContext(context.Context) NatPoolMapOutput
}

NatPoolMapInput is an input type that accepts NatPoolMap and NatPoolMapOutput values. You can construct a concrete instance of `NatPoolMapInput` via: 

NatPoolMap{ "key": NatPoolArgs{...} }

type NatPoolMapOutput 

type NatPoolMapOutput struct{ *pulumi.OutputState }

func (NatPoolMapOutput) ElementType 

func (NatPoolMapOutput) ElementType() reflect.Type

func (NatPoolMapOutput) MapIndex 

func (o NatPoolMapOutput) MapIndex(k pulumi.StringInput) NatPoolOutput

func (NatPoolMapOutput) ToNatPoolMapOutput 

func (o NatPoolMapOutput) ToNatPoolMapOutput() NatPoolMapOutput

func (NatPoolMapOutput) ToNatPoolMapOutputWithContext 

func (o NatPoolMapOutput) ToNatPoolMapOutputWithContext(ctx context.Context) NatPoolMapOutput

type NatPoolOutput 

type NatPoolOutput struct {
	*pulumi.OutputState
}

func (NatPoolOutput) ElementType 

func (NatPoolOutput) ElementType() reflect.Type

func (NatPoolOutput) ToNatPoolOutput 

func (o NatPoolOutput) ToNatPoolOutput() NatPoolOutput

func (NatPoolOutput) ToNatPoolOutputWithContext 

func (o NatPoolOutput) ToNatPoolOutputWithContext(ctx context.Context) NatPoolOutput

func (NatPoolOutput) ToNatPoolPtrOutput 

func (o NatPoolOutput) ToNatPoolPtrOutput() NatPoolPtrOutput

func (NatPoolOutput) ToNatPoolPtrOutputWithContext 

func (o NatPoolOutput) ToNatPoolPtrOutputWithContext(ctx context.Context) NatPoolPtrOutput

type NatPoolPtrInput 

type NatPoolPtrInput interface {
	pulumi.Input

	ToNatPoolPtrOutput() NatPoolPtrOutput
	ToNatPoolPtrOutputWithContext(ctx context.Context) NatPoolPtrOutput
}

type NatPoolPtrOutput 

type NatPoolPtrOutput struct {
	*pulumi.OutputState
}

func (NatPoolPtrOutput) ElementType 

func (NatPoolPtrOutput) ElementType() reflect.Type

func (NatPoolPtrOutput) ToNatPoolPtrOutput 

func (o NatPoolPtrOutput) ToNatPoolPtrOutput() NatPoolPtrOutput

func (NatPoolPtrOutput) ToNatPoolPtrOutputWithContext 

func (o NatPoolPtrOutput) ToNatPoolPtrOutputWithContext(ctx context.Context) NatPoolPtrOutput

type NatPoolState 

type NatPoolState struct {
	// The port used for the internal endpoint. Possible values range between 1 and 65535, inclusive.
	BackendPort               pulumi.IntPtrInput
	FrontendIpConfigurationId pulumi.StringPtrInput
	// The name of the frontend IP configuration exposing this rule.
	FrontendIpConfigurationName pulumi.StringPtrInput
	// The last port number in the range of external ports that will be used to provide Inbound Nat to NICs associated with this Load Balancer. Possible values range between 1 and 65534, inclusive.
	FrontendPortEnd pulumi.IntPtrInput
	// The first port number in the range of external ports that will be used to provide Inbound Nat to NICs associated with this Load Balancer. Possible values range between 1 and 65534, inclusive.
	FrontendPortStart pulumi.IntPtrInput
	// The ID of the Load Balancer in which to create the NAT pool.
	LoadbalancerId pulumi.StringPtrInput
	// Specifies the name of the NAT pool.
	Name pulumi.StringPtrInput
	// The transport protocol for the external endpoint. Possible values are `Udp` or `Tcp`.
	Protocol pulumi.StringPtrInput
	// The name of the resource group in which to create the resource.
	ResourceGroupName pulumi.StringPtrInput
}

func (NatPoolState) ElementType 

func (NatPoolState) ElementType() reflect.Type

type NatRule 

type NatRule struct {
	pulumi.CustomResourceState

	BackendIpConfigurationId pulumi.StringOutput `pulumi:"backendIpConfigurationId"`
	// The port used for internal connections on the endpoint. Possible values range between 1 and 65535, inclusive.
	BackendPort pulumi.IntOutput `pulumi:"backendPort"`
	// Are the Floating IPs enabled for this Load Balncer Rule? A "floating” IP is reassigned to a secondary server in case the primary server fails. Required to configure a SQL AlwaysOn Availability Group. Defaults to `false`.
	EnableFloatingIp pulumi.BoolOutput `pulumi:"enableFloatingIp"`
	// Is TCP Reset enabled for this Load Balancer Rule? Defaults to `false`.
	EnableTcpReset            pulumi.BoolPtrOutput `pulumi:"enableTcpReset"`
	FrontendIpConfigurationId pulumi.StringOutput  `pulumi:"frontendIpConfigurationId"`
	// The name of the frontend IP configuration exposing this rule.
	FrontendIpConfigurationName pulumi.StringOutput `pulumi:"frontendIpConfigurationName"`
	// The port for the external endpoint. Port numbers for each Rule must be unique within the Load Balancer. Possible values range between 1 and 65534, inclusive.
	FrontendPort pulumi.IntOutput `pulumi:"frontendPort"`
	// Specifies the idle timeout in minutes for TCP connections. Valid values are between `4` and `30` minutes. Defaults to `4` minutes.
	IdleTimeoutInMinutes pulumi.IntOutput `pulumi:"idleTimeoutInMinutes"`
	// The ID of the Load Balancer in which to create the NAT Rule.
	LoadbalancerId pulumi.StringOutput `pulumi:"loadbalancerId"`
	// Specifies the name of the NAT Rule.
	Name pulumi.StringOutput `pulumi:"name"`
	// The transport protocol for the external endpoint. Possible values are `Udp`, `Tcp` or `All`.
	Protocol pulumi.StringOutput `pulumi:"protocol"`
	// The name of the resource group in which to create the resource.
	ResourceGroupName pulumi.StringOutput `pulumi:"resourceGroupName"`
}

Manages a Load Balancer NAT Rule.

> **NOTE:** This resource cannot be used with with virtual machine scale sets, instead use the `lb.NatPool` resource.

> **NOTE** When using this resource, the Load Balancer needs to have a FrontEnd IP Configuration Attached

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/lb"
"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/network"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		examplePublicIp, err := network.NewPublicIp(ctx, "examplePublicIp", &network.PublicIpArgs{
			Location:          pulumi.String("West US"),
			ResourceGroupName: exampleResourceGroup.Name,
			AllocationMethod:  pulumi.String("Static"),
		})
		if err != nil {
			return err
		}
		exampleLoadBalancer, err := lb.NewLoadBalancer(ctx, "exampleLoadBalancer", &lb.LoadBalancerArgs{
			Location:          pulumi.String("West US"),
			ResourceGroupName: exampleResourceGroup.Name,
			FrontendIpConfigurations: lb.LoadBalancerFrontendIpConfigurationArray{
				&lb.LoadBalancerFrontendIpConfigurationArgs{
					Name:              pulumi.String("PublicIPAddress"),
					PublicIpAddressId: examplePublicIp.ID(),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = lb.NewNatRule(ctx, "exampleNatRule", &lb.NatRuleArgs{
			ResourceGroupName:           exampleResourceGroup.Name,
			LoadbalancerId:              exampleLoadBalancer.ID(),
			Protocol:                    pulumi.String("Tcp"),
			FrontendPort:                pulumi.Int(3389),
			BackendPort:                 pulumi.Int(3389),
			FrontendIpConfigurationName: pulumi.String("PublicIPAddress"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Load Balancer NAT Rules can be imported using the `resource id`, e.g.

```sh 

$ pulumi import azure:lb/natRule:NatRule example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.Network/loadBalancers/lb1/inboundNatRules/rule1

```

func GetNatRule 

func GetNatRule(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *NatRuleState, opts ...pulumi.ResourceOption) (*NatRule, error)

GetNatRule gets an existing NatRule 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 NewNatRule 

func NewNatRule(ctx *pulumi.Context,
	name string, args *NatRuleArgs, opts ...pulumi.ResourceOption) (*NatRule, error)

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

func (*NatRule) ElementType 

func (*NatRule) ElementType() reflect.Type

func (*NatRule) ToNatRuleOutput 

func (i *NatRule) ToNatRuleOutput() NatRuleOutput

func (*NatRule) ToNatRuleOutputWithContext 

func (i *NatRule) ToNatRuleOutputWithContext(ctx context.Context) NatRuleOutput

func (*NatRule) ToNatRulePtrOutput 

func (i *NatRule) ToNatRulePtrOutput() NatRulePtrOutput

func (*NatRule) ToNatRulePtrOutputWithContext 

func (i *NatRule) ToNatRulePtrOutputWithContext(ctx context.Context) NatRulePtrOutput

type NatRuleArgs 

type NatRuleArgs struct {
	// The port used for internal connections on the endpoint. Possible values range between 1 and 65535, inclusive.
	BackendPort pulumi.IntInput
	// Are the Floating IPs enabled for this Load Balncer Rule? A "floating” IP is reassigned to a secondary server in case the primary server fails. Required to configure a SQL AlwaysOn Availability Group. Defaults to `false`.
	EnableFloatingIp pulumi.BoolPtrInput
	// Is TCP Reset enabled for this Load Balancer Rule? Defaults to `false`.
	EnableTcpReset pulumi.BoolPtrInput
	// The name of the frontend IP configuration exposing this rule.
	FrontendIpConfigurationName pulumi.StringInput
	// The port for the external endpoint. Port numbers for each Rule must be unique within the Load Balancer. Possible values range between 1 and 65534, inclusive.
	FrontendPort pulumi.IntInput
	// Specifies the idle timeout in minutes for TCP connections. Valid values are between `4` and `30` minutes. Defaults to `4` minutes.
	IdleTimeoutInMinutes pulumi.IntPtrInput
	// The ID of the Load Balancer in which to create the NAT Rule.
	LoadbalancerId pulumi.StringInput
	// Specifies the name of the NAT Rule.
	Name pulumi.StringPtrInput
	// The transport protocol for the external endpoint. Possible values are `Udp`, `Tcp` or `All`.
	Protocol pulumi.StringInput
	// The name of the resource group in which to create the resource.
	ResourceGroupName pulumi.StringInput
}

The set of arguments for constructing a NatRule resource.

func (NatRuleArgs) ElementType 

func (NatRuleArgs) ElementType() reflect.Type

type NatRuleArray 

type NatRuleArray []NatRuleInput

func (NatRuleArray) ElementType 

func (NatRuleArray) ElementType() reflect.Type

func (NatRuleArray) ToNatRuleArrayOutput 

func (i NatRuleArray) ToNatRuleArrayOutput() NatRuleArrayOutput

func (NatRuleArray) ToNatRuleArrayOutputWithContext 

func (i NatRuleArray) ToNatRuleArrayOutputWithContext(ctx context.Context) NatRuleArrayOutput

type NatRuleArrayInput 

type NatRuleArrayInput interface {
	pulumi.Input

	ToNatRuleArrayOutput() NatRuleArrayOutput
	ToNatRuleArrayOutputWithContext(context.Context) NatRuleArrayOutput
}

NatRuleArrayInput is an input type that accepts NatRuleArray and NatRuleArrayOutput values. You can construct a concrete instance of `NatRuleArrayInput` via: 

NatRuleArray{ NatRuleArgs{...} }

type NatRuleArrayOutput 

type NatRuleArrayOutput struct{ *pulumi.OutputState }

func (NatRuleArrayOutput) ElementType 

func (NatRuleArrayOutput) ElementType() reflect.Type

func (NatRuleArrayOutput) Index 

func (o NatRuleArrayOutput) Index(i pulumi.IntInput) NatRuleOutput

func (NatRuleArrayOutput) ToNatRuleArrayOutput 

func (o NatRuleArrayOutput) ToNatRuleArrayOutput() NatRuleArrayOutput

func (NatRuleArrayOutput) ToNatRuleArrayOutputWithContext 

func (o NatRuleArrayOutput) ToNatRuleArrayOutputWithContext(ctx context.Context) NatRuleArrayOutput

type NatRuleInput 

type NatRuleInput interface {
	pulumi.Input

	ToNatRuleOutput() NatRuleOutput
	ToNatRuleOutputWithContext(ctx context.Context) NatRuleOutput
}

type NatRuleMap 

type NatRuleMap map[string]NatRuleInput

func (NatRuleMap) ElementType 

func (NatRuleMap) ElementType() reflect.Type

func (NatRuleMap) ToNatRuleMapOutput 

func (i NatRuleMap) ToNatRuleMapOutput() NatRuleMapOutput

func (NatRuleMap) ToNatRuleMapOutputWithContext 

func (i NatRuleMap) ToNatRuleMapOutputWithContext(ctx context.Context) NatRuleMapOutput

type NatRuleMapInput 

type NatRuleMapInput interface {
	pulumi.Input

	ToNatRuleMapOutput() NatRuleMapOutput
	ToNatRuleMapOutputWithContext(context.Context) NatRuleMapOutput
}

NatRuleMapInput is an input type that accepts NatRuleMap and NatRuleMapOutput values. You can construct a concrete instance of `NatRuleMapInput` via: 

NatRuleMap{ "key": NatRuleArgs{...} }

type NatRuleMapOutput 

type NatRuleMapOutput struct{ *pulumi.OutputState }

func (NatRuleMapOutput) ElementType 

func (NatRuleMapOutput) ElementType() reflect.Type

func (NatRuleMapOutput) MapIndex 

func (o NatRuleMapOutput) MapIndex(k pulumi.StringInput) NatRuleOutput

func (NatRuleMapOutput) ToNatRuleMapOutput 

func (o NatRuleMapOutput) ToNatRuleMapOutput() NatRuleMapOutput

func (NatRuleMapOutput) ToNatRuleMapOutputWithContext 

func (o NatRuleMapOutput) ToNatRuleMapOutputWithContext(ctx context.Context) NatRuleMapOutput

type NatRuleOutput 

type NatRuleOutput struct {
	*pulumi.OutputState
}

func (NatRuleOutput) ElementType 

func (NatRuleOutput) ElementType() reflect.Type

func (NatRuleOutput) ToNatRuleOutput 

func (o NatRuleOutput) ToNatRuleOutput() NatRuleOutput

func (NatRuleOutput) ToNatRuleOutputWithContext 

func (o NatRuleOutput) ToNatRuleOutputWithContext(ctx context.Context) NatRuleOutput

func (NatRuleOutput) ToNatRulePtrOutput 

func (o NatRuleOutput) ToNatRulePtrOutput() NatRulePtrOutput

func (NatRuleOutput) ToNatRulePtrOutputWithContext 

func (o NatRuleOutput) ToNatRulePtrOutputWithContext(ctx context.Context) NatRulePtrOutput

type NatRulePtrInput 

type NatRulePtrInput interface {
	pulumi.Input

	ToNatRulePtrOutput() NatRulePtrOutput
	ToNatRulePtrOutputWithContext(ctx context.Context) NatRulePtrOutput
}

type NatRulePtrOutput 

type NatRulePtrOutput struct {
	*pulumi.OutputState
}

func (NatRulePtrOutput) ElementType 

func (NatRulePtrOutput) ElementType() reflect.Type

func (NatRulePtrOutput) ToNatRulePtrOutput 

func (o NatRulePtrOutput) ToNatRulePtrOutput() NatRulePtrOutput

func (NatRulePtrOutput) ToNatRulePtrOutputWithContext 

func (o NatRulePtrOutput) ToNatRulePtrOutputWithContext(ctx context.Context) NatRulePtrOutput

type NatRuleState 

type NatRuleState struct {
	BackendIpConfigurationId pulumi.StringPtrInput
	// The port used for internal connections on the endpoint. Possible values range between 1 and 65535, inclusive.
	BackendPort pulumi.IntPtrInput
	// Are the Floating IPs enabled for this Load Balncer Rule? A "floating” IP is reassigned to a secondary server in case the primary server fails. Required to configure a SQL AlwaysOn Availability Group. Defaults to `false`.
	EnableFloatingIp pulumi.BoolPtrInput
	// Is TCP Reset enabled for this Load Balancer Rule? Defaults to `false`.
	EnableTcpReset            pulumi.BoolPtrInput
	FrontendIpConfigurationId pulumi.StringPtrInput
	// The name of the frontend IP configuration exposing this rule.
	FrontendIpConfigurationName pulumi.StringPtrInput
	// The port for the external endpoint. Port numbers for each Rule must be unique within the Load Balancer. Possible values range between 1 and 65534, inclusive.
	FrontendPort pulumi.IntPtrInput
	// Specifies the idle timeout in minutes for TCP connections. Valid values are between `4` and `30` minutes. Defaults to `4` minutes.
	IdleTimeoutInMinutes pulumi.IntPtrInput
	// The ID of the Load Balancer in which to create the NAT Rule.
	LoadbalancerId pulumi.StringPtrInput
	// Specifies the name of the NAT Rule.
	Name pulumi.StringPtrInput
	// The transport protocol for the external endpoint. Possible values are `Udp`, `Tcp` or `All`.
	Protocol pulumi.StringPtrInput
	// The name of the resource group in which to create the resource.
	ResourceGroupName pulumi.StringPtrInput
}

func (NatRuleState) ElementType 

func (NatRuleState) ElementType() reflect.Type

type OutboundRule 

type OutboundRule struct {
	pulumi.CustomResourceState

	// The number of outbound ports to be used for NAT.
	AllocatedOutboundPorts pulumi.IntPtrOutput `pulumi:"allocatedOutboundPorts"`
	// The ID of the Backend Address Pool. Outbound traffic is randomly load balanced across IPs in the backend IPs.
	BackendAddressPoolId pulumi.StringOutput `pulumi:"backendAddressPoolId"`
	// Receive bidirectional TCP Reset on TCP flow idle timeout or unexpected connection termination. This element is only used when the protocol is set to TCP.
	EnableTcpReset pulumi.BoolPtrOutput `pulumi:"enableTcpReset"`
	// One or more `frontendIpConfiguration` blocks as defined below.
	FrontendIpConfigurations OutboundRuleFrontendIpConfigurationArrayOutput `pulumi:"frontendIpConfigurations"`
	// The timeout for the TCP idle connection
	IdleTimeoutInMinutes pulumi.IntPtrOutput `pulumi:"idleTimeoutInMinutes"`
	// The ID of the Load Balancer in which to create the Outbound Rule. Changing this forces a new resource to be created.
	LoadbalancerId pulumi.StringOutput `pulumi:"loadbalancerId"`
	// Specifies the name of the Outbound Rule. Changing this forces a new resource to be created.
	Name pulumi.StringOutput `pulumi:"name"`
	// The transport protocol for the external endpoint. Possible values are `Udp`, `Tcp` or `All`.
	Protocol pulumi.StringOutput `pulumi:"protocol"`
	// The name of the resource group in which to create the resource. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringOutput `pulumi:"resourceGroupName"`
}

Manages a Load Balancer Outbound Rule.

> **NOTE** When using this resource, the Load Balancer needs to have a FrontEnd IP Configuration and a Backend Address Pool Attached.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/lb"
"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/network"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		examplePublicIp, err := network.NewPublicIp(ctx, "examplePublicIp", &network.PublicIpArgs{
			Location:          pulumi.String("West US"),
			ResourceGroupName: exampleResourceGroup.Name,
			AllocationMethod:  pulumi.String("Static"),
		})
		if err != nil {
			return err
		}
		exampleLoadBalancer, err := lb.NewLoadBalancer(ctx, "exampleLoadBalancer", &lb.LoadBalancerArgs{
			Location:          pulumi.String("West US"),
			ResourceGroupName: exampleResourceGroup.Name,
			FrontendIpConfigurations: lb.LoadBalancerFrontendIpConfigurationArray{
				&lb.LoadBalancerFrontendIpConfigurationArgs{
					Name:              pulumi.String("PublicIPAddress"),
					PublicIpAddressId: examplePublicIp.ID(),
				},
			},
		})
		if err != nil {
			return err
		}
		exampleBackendAddressPool, err := lb.NewBackendAddressPool(ctx, "exampleBackendAddressPool", &lb.BackendAddressPoolArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			LoadbalancerId:    exampleLoadBalancer.ID(),
		})
		if err != nil {
			return err
		}
		_, err = lb.NewOutboundRule(ctx, "exampleOutboundRule", &lb.OutboundRuleArgs{
			ResourceGroupName:    exampleResourceGroup.Name,
			LoadbalancerId:       exampleLoadBalancer.ID(),
			Protocol:             pulumi.String("Tcp"),
			BackendAddressPoolId: exampleBackendAddressPool.ID(),
			FrontendIpConfigurations: lb.OutboundRuleFrontendIpConfigurationArray{
				&lb.OutboundRuleFrontendIpConfigurationArgs{
					Name: pulumi.String("PublicIPAddress"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Load Balancer Outbound Rules can be imported using the `resource id`, e.g.

```sh 

$ pulumi import azure:lb/outboundRule:OutboundRule example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.Network/loadBalancers/lb1/outboundRules/rule1

```

func GetOutboundRule 

func GetOutboundRule(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *OutboundRuleState, opts ...pulumi.ResourceOption) (*OutboundRule, error)

GetOutboundRule gets an existing OutboundRule 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 NewOutboundRule 

func NewOutboundRule(ctx *pulumi.Context,
	name string, args *OutboundRuleArgs, opts ...pulumi.ResourceOption) (*OutboundRule, error)

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

func (*OutboundRule) ElementType 

func (*OutboundRule) ElementType() reflect.Type

func (*OutboundRule) ToOutboundRuleOutput 

func (i *OutboundRule) ToOutboundRuleOutput() OutboundRuleOutput

func (*OutboundRule) ToOutboundRuleOutputWithContext 

func (i *OutboundRule) ToOutboundRuleOutputWithContext(ctx context.Context) OutboundRuleOutput

func (*OutboundRule) ToOutboundRulePtrOutput 

func (i *OutboundRule) ToOutboundRulePtrOutput() OutboundRulePtrOutput

func (*OutboundRule) ToOutboundRulePtrOutputWithContext 

func (i *OutboundRule) ToOutboundRulePtrOutputWithContext(ctx context.Context) OutboundRulePtrOutput

type OutboundRuleArgs 

type OutboundRuleArgs struct {
	// The number of outbound ports to be used for NAT.
	AllocatedOutboundPorts pulumi.IntPtrInput
	// The ID of the Backend Address Pool. Outbound traffic is randomly load balanced across IPs in the backend IPs.
	BackendAddressPoolId pulumi.StringInput
	// Receive bidirectional TCP Reset on TCP flow idle timeout or unexpected connection termination. This element is only used when the protocol is set to TCP.
	EnableTcpReset pulumi.BoolPtrInput
	// One or more `frontendIpConfiguration` blocks as defined below.
	FrontendIpConfigurations OutboundRuleFrontendIpConfigurationArrayInput
	// The timeout for the TCP idle connection
	IdleTimeoutInMinutes pulumi.IntPtrInput
	// The ID of the Load Balancer in which to create the Outbound Rule. Changing this forces a new resource to be created.
	LoadbalancerId pulumi.StringInput
	// Specifies the name of the Outbound Rule. Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// The transport protocol for the external endpoint. Possible values are `Udp`, `Tcp` or `All`.
	Protocol pulumi.StringInput
	// The name of the resource group in which to create the resource. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringInput
}

The set of arguments for constructing a OutboundRule resource.

func (OutboundRuleArgs) ElementType 

func (OutboundRuleArgs) ElementType() reflect.Type

type OutboundRuleArray 

type OutboundRuleArray []OutboundRuleInput

func (OutboundRuleArray) ElementType 

func (OutboundRuleArray) ElementType() reflect.Type

func (OutboundRuleArray) ToOutboundRuleArrayOutput 

func (i OutboundRuleArray) ToOutboundRuleArrayOutput() OutboundRuleArrayOutput

func (OutboundRuleArray) ToOutboundRuleArrayOutputWithContext 

func (i OutboundRuleArray) ToOutboundRuleArrayOutputWithContext(ctx context.Context) OutboundRuleArrayOutput

type OutboundRuleArrayInput 

type OutboundRuleArrayInput interface {
	pulumi.Input

	ToOutboundRuleArrayOutput() OutboundRuleArrayOutput
	ToOutboundRuleArrayOutputWithContext(context.Context) OutboundRuleArrayOutput
}

OutboundRuleArrayInput is an input type that accepts OutboundRuleArray and OutboundRuleArrayOutput values. You can construct a concrete instance of `OutboundRuleArrayInput` via: 

OutboundRuleArray{ OutboundRuleArgs{...} }

type OutboundRuleArrayOutput 

type OutboundRuleArrayOutput struct{ *pulumi.OutputState }

func (OutboundRuleArrayOutput) ElementType 

func (OutboundRuleArrayOutput) ElementType() reflect.Type

func (OutboundRuleArrayOutput) Index 

func (o OutboundRuleArrayOutput) Index(i pulumi.IntInput) OutboundRuleOutput

func (OutboundRuleArrayOutput) ToOutboundRuleArrayOutput 

func (o OutboundRuleArrayOutput) ToOutboundRuleArrayOutput() OutboundRuleArrayOutput

func (OutboundRuleArrayOutput) ToOutboundRuleArrayOutputWithContext 

func (o OutboundRuleArrayOutput) ToOutboundRuleArrayOutputWithContext(ctx context.Context) OutboundRuleArrayOutput

type OutboundRuleFrontendIpConfiguration 

type OutboundRuleFrontendIpConfiguration struct {
	// The ID of the Load Balancer Outbound Rule.
	Id *string `pulumi:"id"`
	// The name of the Frontend IP Configuration.
	Name string `pulumi:"name"`
}

type OutboundRuleFrontendIpConfigurationArgs 

type OutboundRuleFrontendIpConfigurationArgs struct {
	// The ID of the Load Balancer Outbound Rule.
	Id pulumi.StringPtrInput `pulumi:"id"`
	// The name of the Frontend IP Configuration.
	Name pulumi.StringInput `pulumi:"name"`
}

func (OutboundRuleFrontendIpConfigurationArgs) ElementType 

func (OutboundRuleFrontendIpConfigurationArgs) ElementType() reflect.Type

func (OutboundRuleFrontendIpConfigurationArgs) ToOutboundRuleFrontendIpConfigurationOutput 

func (i OutboundRuleFrontendIpConfigurationArgs) ToOutboundRuleFrontendIpConfigurationOutput() OutboundRuleFrontendIpConfigurationOutput

func (OutboundRuleFrontendIpConfigurationArgs) ToOutboundRuleFrontendIpConfigurationOutputWithContext 

func (i OutboundRuleFrontendIpConfigurationArgs) ToOutboundRuleFrontendIpConfigurationOutputWithContext(ctx context.Context) OutboundRuleFrontendIpConfigurationOutput

type OutboundRuleFrontendIpConfigurationArray 

type OutboundRuleFrontendIpConfigurationArray []OutboundRuleFrontendIpConfigurationInput

func (OutboundRuleFrontendIpConfigurationArray) ElementType 

func (OutboundRuleFrontendIpConfigurationArray) ElementType() reflect.Type

func (OutboundRuleFrontendIpConfigurationArray) ToOutboundRuleFrontendIpConfigurationArrayOutput 

func (i OutboundRuleFrontendIpConfigurationArray) ToOutboundRuleFrontendIpConfigurationArrayOutput() OutboundRuleFrontendIpConfigurationArrayOutput

func (OutboundRuleFrontendIpConfigurationArray) ToOutboundRuleFrontendIpConfigurationArrayOutputWithContext 

func (i OutboundRuleFrontendIpConfigurationArray) ToOutboundRuleFrontendIpConfigurationArrayOutputWithContext(ctx context.Context) OutboundRuleFrontendIpConfigurationArrayOutput

type OutboundRuleFrontendIpConfigurationArrayInput 

type OutboundRuleFrontendIpConfigurationArrayInput interface {
	pulumi.Input

	ToOutboundRuleFrontendIpConfigurationArrayOutput() OutboundRuleFrontendIpConfigurationArrayOutput
	ToOutboundRuleFrontendIpConfigurationArrayOutputWithContext(context.Context) OutboundRuleFrontendIpConfigurationArrayOutput
}

OutboundRuleFrontendIpConfigurationArrayInput is an input type that accepts OutboundRuleFrontendIpConfigurationArray and OutboundRuleFrontendIpConfigurationArrayOutput values. You can construct a concrete instance of `OutboundRuleFrontendIpConfigurationArrayInput` via: 

OutboundRuleFrontendIpConfigurationArray{ OutboundRuleFrontendIpConfigurationArgs{...} }

type OutboundRuleFrontendIpConfigurationArrayOutput 

type OutboundRuleFrontendIpConfigurationArrayOutput struct{ *pulumi.OutputState }

func (OutboundRuleFrontendIpConfigurationArrayOutput) ElementType 

func (OutboundRuleFrontendIpConfigurationArrayOutput) ElementType() reflect.Type

func (OutboundRuleFrontendIpConfigurationArrayOutput) Index 

func (o OutboundRuleFrontendIpConfigurationArrayOutput) Index(i pulumi.IntInput) OutboundRuleFrontendIpConfigurationOutput

func (OutboundRuleFrontendIpConfigurationArrayOutput) ToOutboundRuleFrontendIpConfigurationArrayOutput 

func (o OutboundRuleFrontendIpConfigurationArrayOutput) ToOutboundRuleFrontendIpConfigurationArrayOutput() OutboundRuleFrontendIpConfigurationArrayOutput

func (OutboundRuleFrontendIpConfigurationArrayOutput) ToOutboundRuleFrontendIpConfigurationArrayOutputWithContext 

func (o OutboundRuleFrontendIpConfigurationArrayOutput) ToOutboundRuleFrontendIpConfigurationArrayOutputWithContext(ctx context.Context) OutboundRuleFrontendIpConfigurationArrayOutput

type OutboundRuleFrontendIpConfigurationInput 

type OutboundRuleFrontendIpConfigurationInput interface {
	pulumi.Input

	ToOutboundRuleFrontendIpConfigurationOutput() OutboundRuleFrontendIpConfigurationOutput
	ToOutboundRuleFrontendIpConfigurationOutputWithContext(context.Context) OutboundRuleFrontendIpConfigurationOutput
}

OutboundRuleFrontendIpConfigurationInput is an input type that accepts OutboundRuleFrontendIpConfigurationArgs and OutboundRuleFrontendIpConfigurationOutput values. You can construct a concrete instance of `OutboundRuleFrontendIpConfigurationInput` via: 

OutboundRuleFrontendIpConfigurationArgs{...}

type OutboundRuleFrontendIpConfigurationOutput 

type OutboundRuleFrontendIpConfigurationOutput struct{ *pulumi.OutputState }

func (OutboundRuleFrontendIpConfigurationOutput) ElementType 

func (OutboundRuleFrontendIpConfigurationOutput) ElementType() reflect.Type

func (OutboundRuleFrontendIpConfigurationOutput) Id 

func (o OutboundRuleFrontendIpConfigurationOutput) Id() pulumi.StringPtrOutput

The ID of the Load Balancer Outbound Rule.

func (OutboundRuleFrontendIpConfigurationOutput) Name 

func (o OutboundRuleFrontendIpConfigurationOutput) Name() pulumi.StringOutput

The name of the Frontend IP Configuration.

func (OutboundRuleFrontendIpConfigurationOutput) ToOutboundRuleFrontendIpConfigurationOutput 

func (o OutboundRuleFrontendIpConfigurationOutput) ToOutboundRuleFrontendIpConfigurationOutput() OutboundRuleFrontendIpConfigurationOutput

func (OutboundRuleFrontendIpConfigurationOutput) ToOutboundRuleFrontendIpConfigurationOutputWithContext 

func (o OutboundRuleFrontendIpConfigurationOutput) ToOutboundRuleFrontendIpConfigurationOutputWithContext(ctx context.Context) OutboundRuleFrontendIpConfigurationOutput

type OutboundRuleInput 

type OutboundRuleInput interface {
	pulumi.Input

	ToOutboundRuleOutput() OutboundRuleOutput
	ToOutboundRuleOutputWithContext(ctx context.Context) OutboundRuleOutput
}

type OutboundRuleMap 

type OutboundRuleMap map[string]OutboundRuleInput

func (OutboundRuleMap) ElementType 

func (OutboundRuleMap) ElementType() reflect.Type

func (OutboundRuleMap) ToOutboundRuleMapOutput 

func (i OutboundRuleMap) ToOutboundRuleMapOutput() OutboundRuleMapOutput

func (OutboundRuleMap) ToOutboundRuleMapOutputWithContext 

func (i OutboundRuleMap) ToOutboundRuleMapOutputWithContext(ctx context.Context) OutboundRuleMapOutput

type OutboundRuleMapInput 

type OutboundRuleMapInput interface {
	pulumi.Input

	ToOutboundRuleMapOutput() OutboundRuleMapOutput
	ToOutboundRuleMapOutputWithContext(context.Context) OutboundRuleMapOutput
}

OutboundRuleMapInput is an input type that accepts OutboundRuleMap and OutboundRuleMapOutput values. You can construct a concrete instance of `OutboundRuleMapInput` via: 

OutboundRuleMap{ "key": OutboundRuleArgs{...} }

type OutboundRuleMapOutput 

type OutboundRuleMapOutput struct{ *pulumi.OutputState }

func (OutboundRuleMapOutput) ElementType 

func (OutboundRuleMapOutput) ElementType() reflect.Type

func (OutboundRuleMapOutput) MapIndex 

func (o OutboundRuleMapOutput) MapIndex(k pulumi.StringInput) OutboundRuleOutput

func (OutboundRuleMapOutput) ToOutboundRuleMapOutput 

func (o OutboundRuleMapOutput) ToOutboundRuleMapOutput() OutboundRuleMapOutput

func (OutboundRuleMapOutput) ToOutboundRuleMapOutputWithContext 

func (o OutboundRuleMapOutput) ToOutboundRuleMapOutputWithContext(ctx context.Context) OutboundRuleMapOutput

type OutboundRuleOutput 

type OutboundRuleOutput struct {
	*pulumi.OutputState
}

func (OutboundRuleOutput) ElementType 

func (OutboundRuleOutput) ElementType() reflect.Type

func (OutboundRuleOutput) ToOutboundRuleOutput 

func (o OutboundRuleOutput) ToOutboundRuleOutput() OutboundRuleOutput

func (OutboundRuleOutput) ToOutboundRuleOutputWithContext 

func (o OutboundRuleOutput) ToOutboundRuleOutputWithContext(ctx context.Context) OutboundRuleOutput

func (OutboundRuleOutput) ToOutboundRulePtrOutput 

func (o OutboundRuleOutput) ToOutboundRulePtrOutput() OutboundRulePtrOutput

func (OutboundRuleOutput) ToOutboundRulePtrOutputWithContext 

func (o OutboundRuleOutput) ToOutboundRulePtrOutputWithContext(ctx context.Context) OutboundRulePtrOutput

type OutboundRulePtrInput 

type OutboundRulePtrInput interface {
	pulumi.Input

	ToOutboundRulePtrOutput() OutboundRulePtrOutput
	ToOutboundRulePtrOutputWithContext(ctx context.Context) OutboundRulePtrOutput
}

type OutboundRulePtrOutput 

type OutboundRulePtrOutput struct {
	*pulumi.OutputState
}

func (OutboundRulePtrOutput) ElementType 

func (OutboundRulePtrOutput) ElementType() reflect.Type

func (OutboundRulePtrOutput) ToOutboundRulePtrOutput 

func (o OutboundRulePtrOutput) ToOutboundRulePtrOutput() OutboundRulePtrOutput

func (OutboundRulePtrOutput) ToOutboundRulePtrOutputWithContext 

func (o OutboundRulePtrOutput) ToOutboundRulePtrOutputWithContext(ctx context.Context) OutboundRulePtrOutput

type OutboundRuleState 

type OutboundRuleState struct {
	// The number of outbound ports to be used for NAT.
	AllocatedOutboundPorts pulumi.IntPtrInput
	// The ID of the Backend Address Pool. Outbound traffic is randomly load balanced across IPs in the backend IPs.
	BackendAddressPoolId pulumi.StringPtrInput
	// Receive bidirectional TCP Reset on TCP flow idle timeout or unexpected connection termination. This element is only used when the protocol is set to TCP.
	EnableTcpReset pulumi.BoolPtrInput
	// One or more `frontendIpConfiguration` blocks as defined below.
	FrontendIpConfigurations OutboundRuleFrontendIpConfigurationArrayInput
	// The timeout for the TCP idle connection
	IdleTimeoutInMinutes pulumi.IntPtrInput
	// The ID of the Load Balancer in which to create the Outbound Rule. Changing this forces a new resource to be created.
	LoadbalancerId pulumi.StringPtrInput
	// Specifies the name of the Outbound Rule. Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// The transport protocol for the external endpoint. Possible values are `Udp`, `Tcp` or `All`.
	Protocol pulumi.StringPtrInput
	// The name of the resource group in which to create the resource. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringPtrInput
}

func (OutboundRuleState) ElementType 

func (OutboundRuleState) ElementType() reflect.Type

type Probe 

type Probe struct {
	pulumi.CustomResourceState

	// The interval, in seconds between probes to the backend endpoint for health status. The default value is 15, the minimum value is 5.
	IntervalInSeconds pulumi.IntPtrOutput      `pulumi:"intervalInSeconds"`
	LoadBalancerRules pulumi.StringArrayOutput `pulumi:"loadBalancerRules"`
	// The ID of the LoadBalancer in which to create the NAT Rule.
	LoadbalancerId pulumi.StringOutput `pulumi:"loadbalancerId"`
	// Specifies the name of the Probe.
	Name pulumi.StringOutput `pulumi:"name"`
	// The number of failed probe attempts after which the backend endpoint is removed from rotation. The default value is 2. NumberOfProbes multiplied by intervalInSeconds value must be greater or equal to 10.Endpoints are returned to rotation when at least one probe is successful.
	NumberOfProbes pulumi.IntPtrOutput `pulumi:"numberOfProbes"`
	// Port on which the Probe queries the backend endpoint. Possible values range from 1 to 65535, inclusive.
	Port pulumi.IntOutput `pulumi:"port"`
	// Specifies the protocol of the end point. Possible values are `Http`, `Https` or `Tcp`. If Tcp is specified, a received ACK is required for the probe to be successful. If Http is specified, a 200 OK response from the specified URI is required for the probe to be successful.
	Protocol pulumi.StringOutput `pulumi:"protocol"`
	// The URI used for requesting health status from the backend endpoint. Required if protocol is set to `Http` or `Https`. Otherwise, it is not allowed.
	RequestPath pulumi.StringPtrOutput `pulumi:"requestPath"`
	// The name of the resource group in which to create the resource.
	ResourceGroupName pulumi.StringOutput `pulumi:"resourceGroupName"`
}

Manages a LoadBalancer Probe Resource.

> **NOTE** When using this resource, the Load Balancer needs to have a FrontEnd IP Configuration Attached

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/lb"
"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/network"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		examplePublicIp, err := network.NewPublicIp(ctx, "examplePublicIp", &network.PublicIpArgs{
			Location:          pulumi.String("West US"),
			ResourceGroupName: exampleResourceGroup.Name,
			AllocationMethod:  pulumi.String("Static"),
		})
		if err != nil {
			return err
		}
		exampleLoadBalancer, err := lb.NewLoadBalancer(ctx, "exampleLoadBalancer", &lb.LoadBalancerArgs{
			Location:          pulumi.String("West US"),
			ResourceGroupName: exampleResourceGroup.Name,
			FrontendIpConfigurations: lb.LoadBalancerFrontendIpConfigurationArray{
				&lb.LoadBalancerFrontendIpConfigurationArgs{
					Name:              pulumi.String("PublicIPAddress"),
					PublicIpAddressId: examplePublicIp.ID(),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = lb.NewProbe(ctx, "exampleProbe", &lb.ProbeArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			LoadbalancerId:    exampleLoadBalancer.ID(),
			Port:              pulumi.Int(22),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Load Balancer Probes can be imported using the `resource id`, e.g.

```sh 

$ pulumi import azure:lb/probe:Probe example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.Network/loadBalancers/lb1/probes/probe1

```

func GetProbe 

func GetProbe(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ProbeState, opts ...pulumi.ResourceOption) (*Probe, error)

GetProbe gets an existing Probe 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 NewProbe 

func NewProbe(ctx *pulumi.Context,
	name string, args *ProbeArgs, opts ...pulumi.ResourceOption) (*Probe, error)

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

func (*Probe) ElementType 

func (*Probe) ElementType() reflect.Type

func (*Probe) ToProbeOutput 

func (i *Probe) ToProbeOutput() ProbeOutput

func (*Probe) ToProbeOutputWithContext 

func (i *Probe) ToProbeOutputWithContext(ctx context.Context) ProbeOutput

func (*Probe) ToProbePtrOutput 

func (i *Probe) ToProbePtrOutput() ProbePtrOutput

func (*Probe) ToProbePtrOutputWithContext 

func (i *Probe) ToProbePtrOutputWithContext(ctx context.Context) ProbePtrOutput

type ProbeArgs 

type ProbeArgs struct {
	// The interval, in seconds between probes to the backend endpoint for health status. The default value is 15, the minimum value is 5.
	IntervalInSeconds pulumi.IntPtrInput
	// The ID of the LoadBalancer in which to create the NAT Rule.
	LoadbalancerId pulumi.StringInput
	// Specifies the name of the Probe.
	Name pulumi.StringPtrInput
	// The number of failed probe attempts after which the backend endpoint is removed from rotation. The default value is 2. NumberOfProbes multiplied by intervalInSeconds value must be greater or equal to 10.Endpoints are returned to rotation when at least one probe is successful.
	NumberOfProbes pulumi.IntPtrInput
	// Port on which the Probe queries the backend endpoint. Possible values range from 1 to 65535, inclusive.
	Port pulumi.IntInput
	// Specifies the protocol of the end point. Possible values are `Http`, `Https` or `Tcp`. If Tcp is specified, a received ACK is required for the probe to be successful. If Http is specified, a 200 OK response from the specified URI is required for the probe to be successful.
	Protocol pulumi.StringPtrInput
	// The URI used for requesting health status from the backend endpoint. Required if protocol is set to `Http` or `Https`. Otherwise, it is not allowed.
	RequestPath pulumi.StringPtrInput
	// The name of the resource group in which to create the resource.
	ResourceGroupName pulumi.StringInput
}

The set of arguments for constructing a Probe resource.

func (ProbeArgs) ElementType 

func (ProbeArgs) ElementType() reflect.Type

type ProbeArray 

type ProbeArray []ProbeInput

func (ProbeArray) ElementType 

func (ProbeArray) ElementType() reflect.Type

func (ProbeArray) ToProbeArrayOutput 

func (i ProbeArray) ToProbeArrayOutput() ProbeArrayOutput

func (ProbeArray) ToProbeArrayOutputWithContext 

func (i ProbeArray) ToProbeArrayOutputWithContext(ctx context.Context) ProbeArrayOutput

type ProbeArrayInput 

type ProbeArrayInput interface {
	pulumi.Input

	ToProbeArrayOutput() ProbeArrayOutput
	ToProbeArrayOutputWithContext(context.Context) ProbeArrayOutput
}

ProbeArrayInput is an input type that accepts ProbeArray and ProbeArrayOutput values. You can construct a concrete instance of `ProbeArrayInput` via: 

ProbeArray{ ProbeArgs{...} }

type ProbeArrayOutput 

type ProbeArrayOutput struct{ *pulumi.OutputState }

func (ProbeArrayOutput) ElementType 

func (ProbeArrayOutput) ElementType() reflect.Type

func (ProbeArrayOutput) Index 

func (o ProbeArrayOutput) Index(i pulumi.IntInput) ProbeOutput

func (ProbeArrayOutput) ToProbeArrayOutput 

func (o ProbeArrayOutput) ToProbeArrayOutput() ProbeArrayOutput

func (ProbeArrayOutput) ToProbeArrayOutputWithContext 

func (o ProbeArrayOutput) ToProbeArrayOutputWithContext(ctx context.Context) ProbeArrayOutput

type ProbeInput 

type ProbeInput interface {
	pulumi.Input

	ToProbeOutput() ProbeOutput
	ToProbeOutputWithContext(ctx context.Context) ProbeOutput
}

type ProbeMap 

type ProbeMap map[string]ProbeInput

func (ProbeMap) ElementType 

func (ProbeMap) ElementType() reflect.Type

func (ProbeMap) ToProbeMapOutput 

func (i ProbeMap) ToProbeMapOutput() ProbeMapOutput

func (ProbeMap) ToProbeMapOutputWithContext 

func (i ProbeMap) ToProbeMapOutputWithContext(ctx context.Context) ProbeMapOutput

type ProbeMapInput 

type ProbeMapInput interface {
	pulumi.Input

	ToProbeMapOutput() ProbeMapOutput
	ToProbeMapOutputWithContext(context.Context) ProbeMapOutput
}

ProbeMapInput is an input type that accepts ProbeMap and ProbeMapOutput values. You can construct a concrete instance of `ProbeMapInput` via: 

ProbeMap{ "key": ProbeArgs{...} }

type ProbeMapOutput 

type ProbeMapOutput struct{ *pulumi.OutputState }

func (ProbeMapOutput) ElementType 

func (ProbeMapOutput) ElementType() reflect.Type

func (ProbeMapOutput) MapIndex 

func (o ProbeMapOutput) MapIndex(k pulumi.StringInput) ProbeOutput

func (ProbeMapOutput) ToProbeMapOutput 

func (o ProbeMapOutput) ToProbeMapOutput() ProbeMapOutput

func (ProbeMapOutput) ToProbeMapOutputWithContext 

func (o ProbeMapOutput) ToProbeMapOutputWithContext(ctx context.Context) ProbeMapOutput

type ProbeOutput 

type ProbeOutput struct {
	*pulumi.OutputState
}

func (ProbeOutput) ElementType 

func (ProbeOutput) ElementType() reflect.Type

func (ProbeOutput) ToProbeOutput 

func (o ProbeOutput) ToProbeOutput() ProbeOutput

func (ProbeOutput) ToProbeOutputWithContext 

func (o ProbeOutput) ToProbeOutputWithContext(ctx context.Context) ProbeOutput

func (ProbeOutput) ToProbePtrOutput 

func (o ProbeOutput) ToProbePtrOutput() ProbePtrOutput

func (ProbeOutput) ToProbePtrOutputWithContext 

func (o ProbeOutput) ToProbePtrOutputWithContext(ctx context.Context) ProbePtrOutput

type ProbePtrInput 

type ProbePtrInput interface {
	pulumi.Input

	ToProbePtrOutput() ProbePtrOutput
	ToProbePtrOutputWithContext(ctx context.Context) ProbePtrOutput
}

type ProbePtrOutput 

type ProbePtrOutput struct {
	*pulumi.OutputState
}

func (ProbePtrOutput) ElementType 

func (ProbePtrOutput) ElementType() reflect.Type

func (ProbePtrOutput) ToProbePtrOutput 

func (o ProbePtrOutput) ToProbePtrOutput() ProbePtrOutput

func (ProbePtrOutput) ToProbePtrOutputWithContext 

func (o ProbePtrOutput) ToProbePtrOutputWithContext(ctx context.Context) ProbePtrOutput

type ProbeState 

type ProbeState struct {
	// The interval, in seconds between probes to the backend endpoint for health status. The default value is 15, the minimum value is 5.
	IntervalInSeconds pulumi.IntPtrInput
	LoadBalancerRules pulumi.StringArrayInput
	// The ID of the LoadBalancer in which to create the NAT Rule.
	LoadbalancerId pulumi.StringPtrInput
	// Specifies the name of the Probe.
	Name pulumi.StringPtrInput
	// The number of failed probe attempts after which the backend endpoint is removed from rotation. The default value is 2. NumberOfProbes multiplied by intervalInSeconds value must be greater or equal to 10.Endpoints are returned to rotation when at least one probe is successful.
	NumberOfProbes pulumi.IntPtrInput
	// Port on which the Probe queries the backend endpoint. Possible values range from 1 to 65535, inclusive.
	Port pulumi.IntPtrInput
	// Specifies the protocol of the end point. Possible values are `Http`, `Https` or `Tcp`. If Tcp is specified, a received ACK is required for the probe to be successful. If Http is specified, a 200 OK response from the specified URI is required for the probe to be successful.
	Protocol pulumi.StringPtrInput
	// The URI used for requesting health status from the backend endpoint. Required if protocol is set to `Http` or `Https`. Otherwise, it is not allowed.
	RequestPath pulumi.StringPtrInput
	// The name of the resource group in which to create the resource.
	ResourceGroupName pulumi.StringPtrInput
}

func (ProbeState) ElementType 

func (ProbeState) ElementType() reflect.Type

type Rule 

type Rule struct {
	pulumi.CustomResourceState

	// A reference to a Backend Address Pool over which this Load Balancing Rule operates.
	BackendAddressPoolId pulumi.StringOutput `pulumi:"backendAddressPoolId"`
	// The port used for internal connections on the endpoint. Possible values range between 0 and 65535, inclusive.
	BackendPort pulumi.IntOutput `pulumi:"backendPort"`
	// Is snat enabled for this Load Balancer Rule? Default `false`.
	DisableOutboundSnat pulumi.BoolPtrOutput `pulumi:"disableOutboundSnat"`
	// Are the Floating IPs enabled for this Load Balncer Rule? A "floating” IP is reassigned to a secondary server in case the primary server fails. Required to configure a SQL AlwaysOn Availability Group. Defaults to `false`.
	EnableFloatingIp pulumi.BoolPtrOutput `pulumi:"enableFloatingIp"`
	// Is TCP Reset enabled for this Load Balancer Rule? Defaults to `false`.
	EnableTcpReset            pulumi.BoolPtrOutput `pulumi:"enableTcpReset"`
	FrontendIpConfigurationId pulumi.StringOutput  `pulumi:"frontendIpConfigurationId"`
	// The name of the frontend IP configuration to which the rule is associated.
	FrontendIpConfigurationName pulumi.StringOutput `pulumi:"frontendIpConfigurationName"`
	// The port for the external endpoint. Port numbers for each Rule must be unique within the Load Balancer. Possible values range between 0 and 65534, inclusive.
	FrontendPort pulumi.IntOutput `pulumi:"frontendPort"`
	// Specifies the idle timeout in minutes for TCP connections. Valid values are between `4` and `30` minutes. Defaults to `4` minutes.
	IdleTimeoutInMinutes pulumi.IntOutput `pulumi:"idleTimeoutInMinutes"`
	// Specifies the load balancing distribution type to be used by the Load Balancer. Possible values are: `Default` – The load balancer is configured to use a 5 tuple hash to map traffic to available servers. `SourceIP` – The load balancer is configured to use a 2 tuple hash to map traffic to available servers. `SourceIPProtocol` – The load balancer is configured to use a 3 tuple hash to map traffic to available servers. Also known as Session Persistence, where  the options are called `None`, `Client IP` and `Client IP and Protocol` respectively.
	LoadDistribution pulumi.StringOutput `pulumi:"loadDistribution"`
	// The ID of the Load Balancer in which to create the Rule.
	LoadbalancerId pulumi.StringOutput `pulumi:"loadbalancerId"`
	// Specifies the name of the LB Rule.
	Name pulumi.StringOutput `pulumi:"name"`
	// A reference to a Probe used by this Load Balancing Rule.
	ProbeId pulumi.StringOutput `pulumi:"probeId"`
	// The transport protocol for the external endpoint. Possible values are `Tcp`, `Udp` or `All`.
	Protocol pulumi.StringOutput `pulumi:"protocol"`
	// The name of the resource group in which to create the resource.
	ResourceGroupName pulumi.StringOutput `pulumi:"resourceGroupName"`
}

Manages a Load Balancer Rule.

> **NOTE** When using this resource, the Load Balancer needs to have a FrontEnd IP Configuration Attached

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/lb"
"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/network"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		examplePublicIp, err := network.NewPublicIp(ctx, "examplePublicIp", &network.PublicIpArgs{
			Location:          pulumi.String("West US"),
			ResourceGroupName: exampleResourceGroup.Name,
			AllocationMethod:  pulumi.String("Static"),
		})
		if err != nil {
			return err
		}
		exampleLoadBalancer, err := lb.NewLoadBalancer(ctx, "exampleLoadBalancer", &lb.LoadBalancerArgs{
			Location:          pulumi.String("West US"),
			ResourceGroupName: exampleResourceGroup.Name,
			FrontendIpConfigurations: lb.LoadBalancerFrontendIpConfigurationArray{
				&lb.LoadBalancerFrontendIpConfigurationArgs{
					Name:              pulumi.String("PublicIPAddress"),
					PublicIpAddressId: examplePublicIp.ID(),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = lb.NewRule(ctx, "exampleRule", &lb.RuleArgs{
			ResourceGroupName:           exampleResourceGroup.Name,
			LoadbalancerId:              exampleLoadBalancer.ID(),
			Protocol:                    pulumi.String("Tcp"),
			FrontendPort:                pulumi.Int(3389),
			BackendPort:                 pulumi.Int(3389),
			FrontendIpConfigurationName: pulumi.String("PublicIPAddress"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Load Balancer Rules can be imported using the `resource id`, e.g.

```sh 

$ pulumi import azure:lb/rule:Rule example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.Network/loadBalancers/lb1/loadBalancingRules/rule1

```

func GetRule 

func GetRule(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *RuleState, opts ...pulumi.ResourceOption) (*Rule, error)

GetRule gets an existing Rule 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 NewRule 

func NewRule(ctx *pulumi.Context,
	name string, args *RuleArgs, opts ...pulumi.ResourceOption) (*Rule, error)

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

func (*Rule) ElementType 

func (*Rule) ElementType() reflect.Type

func (*Rule) ToRuleOutput 

func (i *Rule) ToRuleOutput() RuleOutput

func (*Rule) ToRuleOutputWithContext 

func (i *Rule) ToRuleOutputWithContext(ctx context.Context) RuleOutput

func (*Rule) ToRulePtrOutput 

func (i *Rule) ToRulePtrOutput() RulePtrOutput

func (*Rule) ToRulePtrOutputWithContext 

func (i *Rule) ToRulePtrOutputWithContext(ctx context.Context) RulePtrOutput

type RuleArgs 

type RuleArgs struct {
	// A reference to a Backend Address Pool over which this Load Balancing Rule operates.
	BackendAddressPoolId pulumi.StringPtrInput
	// The port used for internal connections on the endpoint. Possible values range between 0 and 65535, inclusive.
	BackendPort pulumi.IntInput
	// Is snat enabled for this Load Balancer Rule? Default `false`.
	DisableOutboundSnat pulumi.BoolPtrInput
	// Are the Floating IPs enabled for this Load Balncer Rule? A "floating” IP is reassigned to a secondary server in case the primary server fails. Required to configure a SQL AlwaysOn Availability Group. Defaults to `false`.
	EnableFloatingIp pulumi.BoolPtrInput
	// Is TCP Reset enabled for this Load Balancer Rule? Defaults to `false`.
	EnableTcpReset pulumi.BoolPtrInput
	// The name of the frontend IP configuration to which the rule is associated.
	FrontendIpConfigurationName pulumi.StringInput
	// The port for the external endpoint. Port numbers for each Rule must be unique within the Load Balancer. Possible values range between 0 and 65534, inclusive.
	FrontendPort pulumi.IntInput
	// Specifies the idle timeout in minutes for TCP connections. Valid values are between `4` and `30` minutes. Defaults to `4` minutes.
	IdleTimeoutInMinutes pulumi.IntPtrInput
	// Specifies the load balancing distribution type to be used by the Load Balancer. Possible values are: `Default` – The load balancer is configured to use a 5 tuple hash to map traffic to available servers. `SourceIP` – The load balancer is configured to use a 2 tuple hash to map traffic to available servers. `SourceIPProtocol` – The load balancer is configured to use a 3 tuple hash to map traffic to available servers. Also known as Session Persistence, where  the options are called `None`, `Client IP` and `Client IP and Protocol` respectively.
	LoadDistribution pulumi.StringPtrInput
	// The ID of the Load Balancer in which to create the Rule.
	LoadbalancerId pulumi.StringInput
	// Specifies the name of the LB Rule.
	Name pulumi.StringPtrInput
	// A reference to a Probe used by this Load Balancing Rule.
	ProbeId pulumi.StringPtrInput
	// The transport protocol for the external endpoint. Possible values are `Tcp`, `Udp` or `All`.
	Protocol pulumi.StringInput
	// The name of the resource group in which to create the resource.
	ResourceGroupName pulumi.StringInput
}

The set of arguments for constructing a Rule resource.

func (RuleArgs) ElementType 

func (RuleArgs) ElementType() reflect.Type

type RuleArray 

type RuleArray []RuleInput

func (RuleArray) ElementType 

func (RuleArray) ElementType() reflect.Type

func (RuleArray) ToRuleArrayOutput 

func (i RuleArray) ToRuleArrayOutput() RuleArrayOutput

func (RuleArray) ToRuleArrayOutputWithContext 

func (i RuleArray) ToRuleArrayOutputWithContext(ctx context.Context) RuleArrayOutput

type RuleArrayInput 

type RuleArrayInput interface {
	pulumi.Input

	ToRuleArrayOutput() RuleArrayOutput
	ToRuleArrayOutputWithContext(context.Context) RuleArrayOutput
}

RuleArrayInput is an input type that accepts RuleArray and RuleArrayOutput values. You can construct a concrete instance of `RuleArrayInput` via: 

RuleArray{ RuleArgs{...} }

type RuleArrayOutput 

type RuleArrayOutput struct{ *pulumi.OutputState }

func (RuleArrayOutput) ElementType 

func (RuleArrayOutput) ElementType() reflect.Type

func (RuleArrayOutput) Index 

func (o RuleArrayOutput) Index(i pulumi.IntInput) RuleOutput

func (RuleArrayOutput) ToRuleArrayOutput 

func (o RuleArrayOutput) ToRuleArrayOutput() RuleArrayOutput

func (RuleArrayOutput) ToRuleArrayOutputWithContext 

func (o RuleArrayOutput) ToRuleArrayOutputWithContext(ctx context.Context) RuleArrayOutput

type RuleInput 

type RuleInput interface {
	pulumi.Input

	ToRuleOutput() RuleOutput
	ToRuleOutputWithContext(ctx context.Context) RuleOutput
}

type RuleMap 

type RuleMap map[string]RuleInput

func (RuleMap) ElementType 

func (RuleMap) ElementType() reflect.Type

func (RuleMap) ToRuleMapOutput 

func (i RuleMap) ToRuleMapOutput() RuleMapOutput

func (RuleMap) ToRuleMapOutputWithContext 

func (i RuleMap) ToRuleMapOutputWithContext(ctx context.Context) RuleMapOutput

type RuleMapInput 

type RuleMapInput interface {
	pulumi.Input

	ToRuleMapOutput() RuleMapOutput
	ToRuleMapOutputWithContext(context.Context) RuleMapOutput
}

RuleMapInput is an input type that accepts RuleMap and RuleMapOutput values. You can construct a concrete instance of `RuleMapInput` via: 

RuleMap{ "key": RuleArgs{...} }

type RuleMapOutput 

type RuleMapOutput struct{ *pulumi.OutputState }

func (RuleMapOutput) ElementType 

func (RuleMapOutput) ElementType() reflect.Type

func (RuleMapOutput) MapIndex 

func (o RuleMapOutput) MapIndex(k pulumi.StringInput) RuleOutput

func (RuleMapOutput) ToRuleMapOutput 

func (o RuleMapOutput) ToRuleMapOutput() RuleMapOutput

func (RuleMapOutput) ToRuleMapOutputWithContext 

func (o RuleMapOutput) ToRuleMapOutputWithContext(ctx context.Context) RuleMapOutput

type RuleOutput 

type RuleOutput struct {
	*pulumi.OutputState
}

func (RuleOutput) ElementType 

func (RuleOutput) ElementType() reflect.Type

func (RuleOutput) ToRuleOutput 

func (o RuleOutput) ToRuleOutput() RuleOutput

func (RuleOutput) ToRuleOutputWithContext 

func (o RuleOutput) ToRuleOutputWithContext(ctx context.Context) RuleOutput

func (RuleOutput) ToRulePtrOutput 

func (o RuleOutput) ToRulePtrOutput() RulePtrOutput

func (RuleOutput) ToRulePtrOutputWithContext 

func (o RuleOutput) ToRulePtrOutputWithContext(ctx context.Context) RulePtrOutput

type RulePtrInput 

type RulePtrInput interface {
	pulumi.Input

	ToRulePtrOutput() RulePtrOutput
	ToRulePtrOutputWithContext(ctx context.Context) RulePtrOutput
}

type RulePtrOutput 

type RulePtrOutput struct {
	*pulumi.OutputState
}

func (RulePtrOutput) ElementType 

func (RulePtrOutput) ElementType() reflect.Type

func (RulePtrOutput) ToRulePtrOutput 

func (o RulePtrOutput) ToRulePtrOutput() RulePtrOutput

func (RulePtrOutput) ToRulePtrOutputWithContext 

func (o RulePtrOutput) ToRulePtrOutputWithContext(ctx context.Context) RulePtrOutput

type RuleState 

type RuleState struct {
	// A reference to a Backend Address Pool over which this Load Balancing Rule operates.
	BackendAddressPoolId pulumi.StringPtrInput
	// The port used for internal connections on the endpoint. Possible values range between 0 and 65535, inclusive.
	BackendPort pulumi.IntPtrInput
	// Is snat enabled for this Load Balancer Rule? Default `false`.
	DisableOutboundSnat pulumi.BoolPtrInput
	// Are the Floating IPs enabled for this Load Balncer Rule? A "floating” IP is reassigned to a secondary server in case the primary server fails. Required to configure a SQL AlwaysOn Availability Group. Defaults to `false`.
	EnableFloatingIp pulumi.BoolPtrInput
	// Is TCP Reset enabled for this Load Balancer Rule? Defaults to `false`.
	EnableTcpReset            pulumi.BoolPtrInput
	FrontendIpConfigurationId pulumi.StringPtrInput
	// The name of the frontend IP configuration to which the rule is associated.
	FrontendIpConfigurationName pulumi.StringPtrInput
	// The port for the external endpoint. Port numbers for each Rule must be unique within the Load Balancer. Possible values range between 0 and 65534, inclusive.
	FrontendPort pulumi.IntPtrInput
	// Specifies the idle timeout in minutes for TCP connections. Valid values are between `4` and `30` minutes. Defaults to `4` minutes.
	IdleTimeoutInMinutes pulumi.IntPtrInput
	// Specifies the load balancing distribution type to be used by the Load Balancer. Possible values are: `Default` – The load balancer is configured to use a 5 tuple hash to map traffic to available servers. `SourceIP` – The load balancer is configured to use a 2 tuple hash to map traffic to available servers. `SourceIPProtocol` – The load balancer is configured to use a 3 tuple hash to map traffic to available servers. Also known as Session Persistence, where  the options are called `None`, `Client IP` and `Client IP and Protocol` respectively.
	LoadDistribution pulumi.StringPtrInput
	// The ID of the Load Balancer in which to create the Rule.
	LoadbalancerId pulumi.StringPtrInput
	// Specifies the name of the LB Rule.
	Name pulumi.StringPtrInput
	// A reference to a Probe used by this Load Balancing Rule.
	ProbeId pulumi.StringPtrInput
	// The transport protocol for the external endpoint. Possible values are `Tcp`, `Udp` or `All`.
	Protocol pulumi.StringPtrInput
	// The name of the resource group in which to create the resource.
	ResourceGroupName pulumi.StringPtrInput
}

func (RuleState) ElementType 

func (RuleState) ElementType() reflect.Type

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.