lb

package
v3.56.0 Latest Latest
Warning

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

 Go to latest Published: Apr 12, 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/v3/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/lb"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/network"
"github.com/pulumi/pulumi/sdk/v2/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 added in v3.31.1 

func (*BackendAddressPool) ElementType() reflect.Type

func (*BackendAddressPool) ToBackendAddressPoolOutput added in v3.31.1 

func (i *BackendAddressPool) ToBackendAddressPoolOutput() BackendAddressPoolOutput

func (*BackendAddressPool) ToBackendAddressPoolOutputWithContext added in v3.31.1 

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

func (*BackendAddressPool) ToBackendAddressPoolPtrOutput added in v3.47.1 

func (i *BackendAddressPool) ToBackendAddressPoolPtrOutput() BackendAddressPoolPtrOutput

func (*BackendAddressPool) ToBackendAddressPoolPtrOutputWithContext added in v3.47.1 

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

type BackendAddressPoolAddress added in v3.47.1 

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/v3/go/azure/lb"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/network"
"github.com/pulumi/pulumi/sdk/v2/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 added in v3.47.1 

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 added in v3.47.1 

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 added in v3.47.1 

func (*BackendAddressPoolAddress) ElementType() reflect.Type

func (*BackendAddressPoolAddress) ToBackendAddressPoolAddressOutput added in v3.47.1 

func (i *BackendAddressPoolAddress) ToBackendAddressPoolAddressOutput() BackendAddressPoolAddressOutput

func (*BackendAddressPoolAddress) ToBackendAddressPoolAddressOutputWithContext added in v3.47.1 

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

func (*BackendAddressPoolAddress) ToBackendAddressPoolAddressPtrOutput added in v3.47.1 

func (i *BackendAddressPoolAddress) ToBackendAddressPoolAddressPtrOutput() BackendAddressPoolAddressPtrOutput

func (*BackendAddressPoolAddress) ToBackendAddressPoolAddressPtrOutputWithContext added in v3.47.1 

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

type BackendAddressPoolAddressArgs added in v3.47.1 

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 added in v3.47.1 

func (BackendAddressPoolAddressArgs) ElementType() reflect.Type

type BackendAddressPoolAddressArray added in v3.47.1 

type BackendAddressPoolAddressArray []BackendAddressPoolAddressInput

func (BackendAddressPoolAddressArray) ElementType added in v3.47.1 

func (BackendAddressPoolAddressArray) ElementType() reflect.Type

func (BackendAddressPoolAddressArray) ToBackendAddressPoolAddressArrayOutput added in v3.47.1 

func (i BackendAddressPoolAddressArray) ToBackendAddressPoolAddressArrayOutput() BackendAddressPoolAddressArrayOutput

func (BackendAddressPoolAddressArray) ToBackendAddressPoolAddressArrayOutputWithContext added in v3.47.1 

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

type BackendAddressPoolAddressArrayInput added in v3.47.1 

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 added in v3.47.1 

type BackendAddressPoolAddressArrayOutput struct{ *pulumi.OutputState }

func (BackendAddressPoolAddressArrayOutput) ElementType added in v3.47.1 

func (BackendAddressPoolAddressArrayOutput) ElementType() reflect.Type

func (BackendAddressPoolAddressArrayOutput) Index added in v3.47.1 

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

func (BackendAddressPoolAddressArrayOutput) ToBackendAddressPoolAddressArrayOutput added in v3.47.1 

func (o BackendAddressPoolAddressArrayOutput) ToBackendAddressPoolAddressArrayOutput() BackendAddressPoolAddressArrayOutput

func (BackendAddressPoolAddressArrayOutput) ToBackendAddressPoolAddressArrayOutputWithContext added in v3.47.1 

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

type BackendAddressPoolAddressInput added in v3.47.1 

type BackendAddressPoolAddressInput interface {
	pulumi.Input

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

type BackendAddressPoolAddressMap added in v3.47.1 

type BackendAddressPoolAddressMap map[string]BackendAddressPoolAddressInput

func (BackendAddressPoolAddressMap) ElementType added in v3.47.1 

func (BackendAddressPoolAddressMap) ElementType() reflect.Type

func (BackendAddressPoolAddressMap) ToBackendAddressPoolAddressMapOutput added in v3.47.1 

func (i BackendAddressPoolAddressMap) ToBackendAddressPoolAddressMapOutput() BackendAddressPoolAddressMapOutput

func (BackendAddressPoolAddressMap) ToBackendAddressPoolAddressMapOutputWithContext added in v3.47.1 

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

type BackendAddressPoolAddressMapInput added in v3.47.1 

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 added in v3.47.1 

type BackendAddressPoolAddressMapOutput struct{ *pulumi.OutputState }

func (BackendAddressPoolAddressMapOutput) ElementType added in v3.47.1 

func (BackendAddressPoolAddressMapOutput) ElementType() reflect.Type

func (BackendAddressPoolAddressMapOutput) MapIndex added in v3.47.1 

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

func (BackendAddressPoolAddressMapOutput) ToBackendAddressPoolAddressMapOutput added in v3.47.1 

func (o BackendAddressPoolAddressMapOutput) ToBackendAddressPoolAddressMapOutput() BackendAddressPoolAddressMapOutput

func (BackendAddressPoolAddressMapOutput) ToBackendAddressPoolAddressMapOutputWithContext added in v3.47.1 

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

type BackendAddressPoolAddressOutput added in v3.47.1 

type BackendAddressPoolAddressOutput struct {
	*pulumi.OutputState
}

func (BackendAddressPoolAddressOutput) ElementType added in v3.47.1 

func (BackendAddressPoolAddressOutput) ElementType() reflect.Type

func (BackendAddressPoolAddressOutput) ToBackendAddressPoolAddressOutput added in v3.47.1 

func (o BackendAddressPoolAddressOutput) ToBackendAddressPoolAddressOutput() BackendAddressPoolAddressOutput

func (BackendAddressPoolAddressOutput) ToBackendAddressPoolAddressOutputWithContext added in v3.47.1 

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

func (BackendAddressPoolAddressOutput) ToBackendAddressPoolAddressPtrOutput added in v3.47.1 

func (o BackendAddressPoolAddressOutput) ToBackendAddressPoolAddressPtrOutput() BackendAddressPoolAddressPtrOutput

func (BackendAddressPoolAddressOutput) ToBackendAddressPoolAddressPtrOutputWithContext added in v3.47.1 

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

type BackendAddressPoolAddressPtrInput added in v3.47.1 

type BackendAddressPoolAddressPtrInput interface {
	pulumi.Input

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

type BackendAddressPoolAddressPtrOutput added in v3.47.1 

type BackendAddressPoolAddressPtrOutput struct {
	*pulumi.OutputState
}

func (BackendAddressPoolAddressPtrOutput) ElementType added in v3.47.1 

func (BackendAddressPoolAddressPtrOutput) ElementType() reflect.Type

func (BackendAddressPoolAddressPtrOutput) ToBackendAddressPoolAddressPtrOutput added in v3.47.1 

func (o BackendAddressPoolAddressPtrOutput) ToBackendAddressPoolAddressPtrOutput() BackendAddressPoolAddressPtrOutput

func (BackendAddressPoolAddressPtrOutput) ToBackendAddressPoolAddressPtrOutputWithContext added in v3.47.1 

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

type BackendAddressPoolAddressState added in v3.47.1 

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 added in v3.47.1 

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 added in v3.47.1 

type BackendAddressPoolArray []BackendAddressPoolInput

func (BackendAddressPoolArray) ElementType added in v3.47.1 

func (BackendAddressPoolArray) ElementType() reflect.Type

func (BackendAddressPoolArray) ToBackendAddressPoolArrayOutput added in v3.47.1 

func (i BackendAddressPoolArray) ToBackendAddressPoolArrayOutput() BackendAddressPoolArrayOutput

func (BackendAddressPoolArray) ToBackendAddressPoolArrayOutputWithContext added in v3.47.1 

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

type BackendAddressPoolArrayInput added in v3.47.1 

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 added in v3.47.1 

type BackendAddressPoolArrayOutput struct{ *pulumi.OutputState }

func (BackendAddressPoolArrayOutput) ElementType added in v3.47.1 

func (BackendAddressPoolArrayOutput) ElementType() reflect.Type

func (BackendAddressPoolArrayOutput) Index added in v3.47.1 

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

func (BackendAddressPoolArrayOutput) ToBackendAddressPoolArrayOutput added in v3.47.1 

func (o BackendAddressPoolArrayOutput) ToBackendAddressPoolArrayOutput() BackendAddressPoolArrayOutput

func (BackendAddressPoolArrayOutput) ToBackendAddressPoolArrayOutputWithContext added in v3.47.1 

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

type BackendAddressPoolBackendAddress added in v3.46.0 

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 added in v3.46.0 

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 added in v3.46.0 

func (BackendAddressPoolBackendAddressArgs) ElementType() reflect.Type

func (BackendAddressPoolBackendAddressArgs) ToBackendAddressPoolBackendAddressOutput added in v3.46.0 

func (i BackendAddressPoolBackendAddressArgs) ToBackendAddressPoolBackendAddressOutput() BackendAddressPoolBackendAddressOutput

func (BackendAddressPoolBackendAddressArgs) ToBackendAddressPoolBackendAddressOutputWithContext added in v3.46.0 

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

type BackendAddressPoolBackendAddressArray added in v3.46.0 

type BackendAddressPoolBackendAddressArray []BackendAddressPoolBackendAddressInput

func (BackendAddressPoolBackendAddressArray) ElementType added in v3.46.0 

func (BackendAddressPoolBackendAddressArray) ElementType() reflect.Type

func (BackendAddressPoolBackendAddressArray) ToBackendAddressPoolBackendAddressArrayOutput added in v3.46.0 

func (i BackendAddressPoolBackendAddressArray) ToBackendAddressPoolBackendAddressArrayOutput() BackendAddressPoolBackendAddressArrayOutput

func (BackendAddressPoolBackendAddressArray) ToBackendAddressPoolBackendAddressArrayOutputWithContext added in v3.46.0 

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

type BackendAddressPoolBackendAddressArrayInput added in v3.46.0 

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 added in v3.46.0 

type BackendAddressPoolBackendAddressArrayOutput struct{ *pulumi.OutputState }

func (BackendAddressPoolBackendAddressArrayOutput) ElementType added in v3.46.0 

func (BackendAddressPoolBackendAddressArrayOutput) ElementType() reflect.Type

func (BackendAddressPoolBackendAddressArrayOutput) Index added in v3.46.0 

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

func (BackendAddressPoolBackendAddressArrayOutput) ToBackendAddressPoolBackendAddressArrayOutput added in v3.46.0 

func (o BackendAddressPoolBackendAddressArrayOutput) ToBackendAddressPoolBackendAddressArrayOutput() BackendAddressPoolBackendAddressArrayOutput

func (BackendAddressPoolBackendAddressArrayOutput) ToBackendAddressPoolBackendAddressArrayOutputWithContext added in v3.46.0 

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

type BackendAddressPoolBackendAddressInput added in v3.46.0 

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 added in v3.46.0 

type BackendAddressPoolBackendAddressOutput struct{ *pulumi.OutputState }

func (BackendAddressPoolBackendAddressOutput) ElementType added in v3.46.0 

func (BackendAddressPoolBackendAddressOutput) ElementType() reflect.Type

func (BackendAddressPoolBackendAddressOutput) IpAddress added in v3.46.0 

func (o BackendAddressPoolBackendAddressOutput) IpAddress() pulumi.StringOutput

func (BackendAddressPoolBackendAddressOutput) Name added in v3.46.0 

func (o BackendAddressPoolBackendAddressOutput) Name() pulumi.StringOutput

Specifies the name of the Backend Address Pool.

func (BackendAddressPoolBackendAddressOutput) ToBackendAddressPoolBackendAddressOutput added in v3.46.0 

func (o BackendAddressPoolBackendAddressOutput) ToBackendAddressPoolBackendAddressOutput() BackendAddressPoolBackendAddressOutput

func (BackendAddressPoolBackendAddressOutput) ToBackendAddressPoolBackendAddressOutputWithContext added in v3.46.0 

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

func (BackendAddressPoolBackendAddressOutput) VirtualNetworkId added in v3.46.0 

func (o BackendAddressPoolBackendAddressOutput) VirtualNetworkId() pulumi.StringOutput

type BackendAddressPoolInput added in v3.31.1 

type BackendAddressPoolInput interface {
	pulumi.Input

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

type BackendAddressPoolMap added in v3.47.1 

type BackendAddressPoolMap map[string]BackendAddressPoolInput

func (BackendAddressPoolMap) ElementType added in v3.47.1 

func (BackendAddressPoolMap) ElementType() reflect.Type

func (BackendAddressPoolMap) ToBackendAddressPoolMapOutput added in v3.47.1 

func (i BackendAddressPoolMap) ToBackendAddressPoolMapOutput() BackendAddressPoolMapOutput

func (BackendAddressPoolMap) ToBackendAddressPoolMapOutputWithContext added in v3.47.1 

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

type BackendAddressPoolMapInput added in v3.47.1 

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 added in v3.47.1 

type BackendAddressPoolMapOutput struct{ *pulumi.OutputState }

func (BackendAddressPoolMapOutput) ElementType added in v3.47.1 

func (BackendAddressPoolMapOutput) ElementType() reflect.Type

func (BackendAddressPoolMapOutput) MapIndex added in v3.47.1 

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

func (BackendAddressPoolMapOutput) ToBackendAddressPoolMapOutput added in v3.47.1 

func (o BackendAddressPoolMapOutput) ToBackendAddressPoolMapOutput() BackendAddressPoolMapOutput

func (BackendAddressPoolMapOutput) ToBackendAddressPoolMapOutputWithContext added in v3.47.1 

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

type BackendAddressPoolOutput added in v3.31.1 

type BackendAddressPoolOutput struct {
	*pulumi.OutputState
}

func (BackendAddressPoolOutput) ElementType added in v3.31.1 

func (BackendAddressPoolOutput) ElementType() reflect.Type

func (BackendAddressPoolOutput) ToBackendAddressPoolOutput added in v3.31.1 

func (o BackendAddressPoolOutput) ToBackendAddressPoolOutput() BackendAddressPoolOutput

func (BackendAddressPoolOutput) ToBackendAddressPoolOutputWithContext added in v3.31.1 

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

func (BackendAddressPoolOutput) ToBackendAddressPoolPtrOutput added in v3.47.1 

func (o BackendAddressPoolOutput) ToBackendAddressPoolPtrOutput() BackendAddressPoolPtrOutput

func (BackendAddressPoolOutput) ToBackendAddressPoolPtrOutputWithContext added in v3.47.1 

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

type BackendAddressPoolPtrInput added in v3.47.1 

type BackendAddressPoolPtrInput interface {
	pulumi.Input

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

type BackendAddressPoolPtrOutput added in v3.47.1 

type BackendAddressPoolPtrOutput struct {
	*pulumi.OutputState
}

func (BackendAddressPoolPtrOutput) ElementType added in v3.47.1 

func (BackendAddressPoolPtrOutput) ElementType() reflect.Type

func (BackendAddressPoolPtrOutput) ToBackendAddressPoolPtrOutput added in v3.47.1 

func (o BackendAddressPoolPtrOutput) ToBackendAddressPoolPtrOutput() BackendAddressPoolPtrOutput

func (BackendAddressPoolPtrOutput) ToBackendAddressPoolPtrOutputWithContext added in v3.47.1 

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 added in v3.46.0 

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 added in v3.46.0 

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 added in v3.46.0 

func (GetBackendAddressPoolBackendAddressArgs) ElementType() reflect.Type

func (GetBackendAddressPoolBackendAddressArgs) ToGetBackendAddressPoolBackendAddressOutput added in v3.46.0 

func (i GetBackendAddressPoolBackendAddressArgs) ToGetBackendAddressPoolBackendAddressOutput() GetBackendAddressPoolBackendAddressOutput

func (GetBackendAddressPoolBackendAddressArgs) ToGetBackendAddressPoolBackendAddressOutputWithContext added in v3.46.0 

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

type GetBackendAddressPoolBackendAddressArray added in v3.46.0 

type GetBackendAddressPoolBackendAddressArray []GetBackendAddressPoolBackendAddressInput

func (GetBackendAddressPoolBackendAddressArray) ElementType added in v3.46.0 

func (GetBackendAddressPoolBackendAddressArray) ElementType() reflect.Type

func (GetBackendAddressPoolBackendAddressArray) ToGetBackendAddressPoolBackendAddressArrayOutput added in v3.46.0 

func (i GetBackendAddressPoolBackendAddressArray) ToGetBackendAddressPoolBackendAddressArrayOutput() GetBackendAddressPoolBackendAddressArrayOutput

func (GetBackendAddressPoolBackendAddressArray) ToGetBackendAddressPoolBackendAddressArrayOutputWithContext added in v3.46.0 

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

type GetBackendAddressPoolBackendAddressArrayInput added in v3.46.0 

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 added in v3.46.0 

type GetBackendAddressPoolBackendAddressArrayOutput struct{ *pulumi.OutputState }

func (GetBackendAddressPoolBackendAddressArrayOutput) ElementType added in v3.46.0 

func (GetBackendAddressPoolBackendAddressArrayOutput) ElementType() reflect.Type

func (GetBackendAddressPoolBackendAddressArrayOutput) Index added in v3.46.0 

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

func (GetBackendAddressPoolBackendAddressArrayOutput) ToGetBackendAddressPoolBackendAddressArrayOutput added in v3.46.0 

func (o GetBackendAddressPoolBackendAddressArrayOutput) ToGetBackendAddressPoolBackendAddressArrayOutput() GetBackendAddressPoolBackendAddressArrayOutput

func (GetBackendAddressPoolBackendAddressArrayOutput) ToGetBackendAddressPoolBackendAddressArrayOutputWithContext added in v3.46.0 

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

type GetBackendAddressPoolBackendAddressInput added in v3.46.0 

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 added in v3.46.0 

type GetBackendAddressPoolBackendAddressOutput struct{ *pulumi.OutputState }

func (GetBackendAddressPoolBackendAddressOutput) ElementType added in v3.46.0 

func (GetBackendAddressPoolBackendAddressOutput) ElementType() reflect.Type

func (GetBackendAddressPoolBackendAddressOutput) IpAddress added in v3.46.0 

func (o GetBackendAddressPoolBackendAddressOutput) IpAddress() pulumi.StringOutput

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

func (GetBackendAddressPoolBackendAddressOutput) Name added in v3.46.0 

func (o GetBackendAddressPoolBackendAddressOutput) Name() pulumi.StringOutput

Specifies the name of the Backend Address Pool.

func (GetBackendAddressPoolBackendAddressOutput) ToGetBackendAddressPoolBackendAddressOutput added in v3.46.0 

func (o GetBackendAddressPoolBackendAddressOutput) ToGetBackendAddressPoolBackendAddressOutput() GetBackendAddressPoolBackendAddressOutput

func (GetBackendAddressPoolBackendAddressOutput) ToGetBackendAddressPoolBackendAddressOutputWithContext added in v3.46.0 

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

func (GetBackendAddressPoolBackendAddressOutput) VirtualNetworkId added in v3.46.0 

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/v3/go/azure/lb"
"github.com/pulumi/pulumi/sdk/v2/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 added in v3.21.0 

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 added in v3.21.0 

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 added in v3.21.0 

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/v3/go/azure/lb"
"github.com/pulumi/pulumi/sdk/v2/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/v3/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/lb"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/network"
"github.com/pulumi/pulumi/sdk/v2/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 added in v3.31.1 

func (*LoadBalancer) ElementType() reflect.Type

func (*LoadBalancer) ToLoadBalancerOutput added in v3.31.1 

func (i *LoadBalancer) ToLoadBalancerOutput() LoadBalancerOutput

func (*LoadBalancer) ToLoadBalancerOutputWithContext added in v3.31.1 

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

func (*LoadBalancer) ToLoadBalancerPtrOutput added in v3.47.1 

func (i *LoadBalancer) ToLoadBalancerPtrOutput() LoadBalancerPtrOutput

func (*LoadBalancer) ToLoadBalancerPtrOutputWithContext added in v3.47.1 

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 added in v3.47.1 

type LoadBalancerArray []LoadBalancerInput

func (LoadBalancerArray) ElementType added in v3.47.1 

func (LoadBalancerArray) ElementType() reflect.Type

func (LoadBalancerArray) ToLoadBalancerArrayOutput added in v3.47.1 

func (i LoadBalancerArray) ToLoadBalancerArrayOutput() LoadBalancerArrayOutput

func (LoadBalancerArray) ToLoadBalancerArrayOutputWithContext added in v3.47.1 

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

type LoadBalancerArrayInput added in v3.47.1 

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 added in v3.47.1 

type LoadBalancerArrayOutput struct{ *pulumi.OutputState }

func (LoadBalancerArrayOutput) ElementType added in v3.47.1 

func (LoadBalancerArrayOutput) ElementType() reflect.Type

func (LoadBalancerArrayOutput) Index added in v3.47.1 

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

func (LoadBalancerArrayOutput) ToLoadBalancerArrayOutput added in v3.47.1 

func (o LoadBalancerArrayOutput) ToLoadBalancerArrayOutput() LoadBalancerArrayOutput

func (LoadBalancerArrayOutput) ToLoadBalancerArrayOutputWithContext added in v3.47.1 

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

type LoadBalancerFrontendIpConfiguration 

type LoadBalancerFrontendIpConfiguration struct {
	// 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"`
	// A list of Availability Zones which the Load Balancer's IP Addresses should be created in.
	Zones *string `pulumi:"zones"`
}

type LoadBalancerFrontendIpConfigurationArgs 

type LoadBalancerFrontendIpConfigurationArgs struct {
	// 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"`
	// A list of Availability Zones which the Load Balancer's IP Addresses should be created in.
	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) 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 

func (o LoadBalancerFrontendIpConfigurationOutput) Zones() pulumi.StringPtrOutput

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

type LoadBalancerInput added in v3.31.1 

type LoadBalancerInput interface {
	pulumi.Input

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

type LoadBalancerMap added in v3.47.1 

type LoadBalancerMap map[string]LoadBalancerInput

func (LoadBalancerMap) ElementType added in v3.47.1 

func (LoadBalancerMap) ElementType() reflect.Type

func (LoadBalancerMap) ToLoadBalancerMapOutput added in v3.47.1 

func (i LoadBalancerMap) ToLoadBalancerMapOutput() LoadBalancerMapOutput

func (LoadBalancerMap) ToLoadBalancerMapOutputWithContext added in v3.47.1 

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

type LoadBalancerMapInput added in v3.47.1 

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 added in v3.47.1 

type LoadBalancerMapOutput struct{ *pulumi.OutputState }

func (LoadBalancerMapOutput) ElementType added in v3.47.1 

func (LoadBalancerMapOutput) ElementType() reflect.Type

func (LoadBalancerMapOutput) MapIndex added in v3.47.1 

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

func (LoadBalancerMapOutput) ToLoadBalancerMapOutput added in v3.47.1 

func (o LoadBalancerMapOutput) ToLoadBalancerMapOutput() LoadBalancerMapOutput

func (LoadBalancerMapOutput) ToLoadBalancerMapOutputWithContext added in v3.47.1 

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

type LoadBalancerOutput added in v3.31.1 

type LoadBalancerOutput struct {
	*pulumi.OutputState
}

func (LoadBalancerOutput) ElementType added in v3.31.1 

func (LoadBalancerOutput) ElementType() reflect.Type

func (LoadBalancerOutput) ToLoadBalancerOutput added in v3.31.1 

func (o LoadBalancerOutput) ToLoadBalancerOutput() LoadBalancerOutput

func (LoadBalancerOutput) ToLoadBalancerOutputWithContext added in v3.31.1 

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

func (LoadBalancerOutput) ToLoadBalancerPtrOutput added in v3.47.1 

func (o LoadBalancerOutput) ToLoadBalancerPtrOutput() LoadBalancerPtrOutput

func (LoadBalancerOutput) ToLoadBalancerPtrOutputWithContext added in v3.47.1 

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

type LoadBalancerPtrInput added in v3.47.1 

type LoadBalancerPtrInput interface {
	pulumi.Input

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

type LoadBalancerPtrOutput added in v3.47.1 

type LoadBalancerPtrOutput struct {
	*pulumi.OutputState
}

func (LoadBalancerPtrOutput) ElementType added in v3.47.1 

func (LoadBalancerPtrOutput) ElementType() reflect.Type

func (LoadBalancerPtrOutput) ToLoadBalancerPtrOutput added in v3.47.1 

func (o LoadBalancerPtrOutput) ToLoadBalancerPtrOutput() LoadBalancerPtrOutput

func (LoadBalancerPtrOutput) ToLoadBalancerPtrOutputWithContext added in v3.47.1 

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/v3/go/azure/lb"
"github.com/pulumi/pulumi/sdk/v2/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/v3/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/lb"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/network"
"github.com/pulumi/pulumi/sdk/v2/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 added in v3.31.1 

func (*NatPool) ElementType() reflect.Type

func (*NatPool) ToNatPoolOutput added in v3.31.1 

func (i *NatPool) ToNatPoolOutput() NatPoolOutput

func (*NatPool) ToNatPoolOutputWithContext added in v3.31.1 

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

func (*NatPool) ToNatPoolPtrOutput added in v3.47.1 

func (i *NatPool) ToNatPoolPtrOutput() NatPoolPtrOutput

func (*NatPool) ToNatPoolPtrOutputWithContext added in v3.47.1 

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 added in v3.47.1 

type NatPoolArray []NatPoolInput

func (NatPoolArray) ElementType added in v3.47.1 

func (NatPoolArray) ElementType() reflect.Type

func (NatPoolArray) ToNatPoolArrayOutput added in v3.47.1 

func (i NatPoolArray) ToNatPoolArrayOutput() NatPoolArrayOutput

func (NatPoolArray) ToNatPoolArrayOutputWithContext added in v3.47.1 

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

type NatPoolArrayInput added in v3.47.1 

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 added in v3.47.1 

type NatPoolArrayOutput struct{ *pulumi.OutputState }

func (NatPoolArrayOutput) ElementType added in v3.47.1 

func (NatPoolArrayOutput) ElementType() reflect.Type

func (NatPoolArrayOutput) Index added in v3.47.1 

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

func (NatPoolArrayOutput) ToNatPoolArrayOutput added in v3.47.1 

func (o NatPoolArrayOutput) ToNatPoolArrayOutput() NatPoolArrayOutput

func (NatPoolArrayOutput) ToNatPoolArrayOutputWithContext added in v3.47.1 

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

type NatPoolInput added in v3.31.1 

type NatPoolInput interface {
	pulumi.Input

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

type NatPoolMap added in v3.47.1 

type NatPoolMap map[string]NatPoolInput

func (NatPoolMap) ElementType added in v3.47.1 

func (NatPoolMap) ElementType() reflect.Type

func (NatPoolMap) ToNatPoolMapOutput added in v3.47.1 

func (i NatPoolMap) ToNatPoolMapOutput() NatPoolMapOutput

func (NatPoolMap) ToNatPoolMapOutputWithContext added in v3.47.1 

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

type NatPoolMapInput added in v3.47.1 

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 added in v3.47.1 

type NatPoolMapOutput struct{ *pulumi.OutputState }

func (NatPoolMapOutput) ElementType added in v3.47.1 

func (NatPoolMapOutput) ElementType() reflect.Type

func (NatPoolMapOutput) MapIndex added in v3.47.1 

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

func (NatPoolMapOutput) ToNatPoolMapOutput added in v3.47.1 

func (o NatPoolMapOutput) ToNatPoolMapOutput() NatPoolMapOutput

func (NatPoolMapOutput) ToNatPoolMapOutputWithContext added in v3.47.1 

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

type NatPoolOutput added in v3.31.1 

type NatPoolOutput struct {
	*pulumi.OutputState
}

func (NatPoolOutput) ElementType added in v3.31.1 

func (NatPoolOutput) ElementType() reflect.Type

func (NatPoolOutput) ToNatPoolOutput added in v3.31.1 

func (o NatPoolOutput) ToNatPoolOutput() NatPoolOutput

func (NatPoolOutput) ToNatPoolOutputWithContext added in v3.31.1 

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

func (NatPoolOutput) ToNatPoolPtrOutput added in v3.47.1 

func (o NatPoolOutput) ToNatPoolPtrOutput() NatPoolPtrOutput

func (NatPoolOutput) ToNatPoolPtrOutputWithContext added in v3.47.1 

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

type NatPoolPtrInput added in v3.47.1 

type NatPoolPtrInput interface {
	pulumi.Input

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

type NatPoolPtrOutput added in v3.47.1 

type NatPoolPtrOutput struct {
	*pulumi.OutputState
}

func (NatPoolPtrOutput) ElementType added in v3.47.1 

func (NatPoolPtrOutput) ElementType() reflect.Type

func (NatPoolPtrOutput) ToNatPoolPtrOutput added in v3.47.1 

func (o NatPoolPtrOutput) ToNatPoolPtrOutput() NatPoolPtrOutput

func (NatPoolPtrOutput) ToNatPoolPtrOutputWithContext added in v3.47.1 

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/v3/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/lb"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/network"
"github.com/pulumi/pulumi/sdk/v2/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 added in v3.31.1 

func (*NatRule) ElementType() reflect.Type

func (*NatRule) ToNatRuleOutput added in v3.31.1 

func (i *NatRule) ToNatRuleOutput() NatRuleOutput

func (*NatRule) ToNatRuleOutputWithContext added in v3.31.1 

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

func (*NatRule) ToNatRulePtrOutput added in v3.47.1 

func (i *NatRule) ToNatRulePtrOutput() NatRulePtrOutput

func (*NatRule) ToNatRulePtrOutputWithContext added in v3.47.1 

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 added in v3.47.1 

type NatRuleArray []NatRuleInput

func (NatRuleArray) ElementType added in v3.47.1 

func (NatRuleArray) ElementType() reflect.Type

func (NatRuleArray) ToNatRuleArrayOutput added in v3.47.1 

func (i NatRuleArray) ToNatRuleArrayOutput() NatRuleArrayOutput

func (NatRuleArray) ToNatRuleArrayOutputWithContext added in v3.47.1 

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

type NatRuleArrayInput added in v3.47.1 

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 added in v3.47.1 

type NatRuleArrayOutput struct{ *pulumi.OutputState }

func (NatRuleArrayOutput) ElementType added in v3.47.1 

func (NatRuleArrayOutput) ElementType() reflect.Type

func (NatRuleArrayOutput) Index added in v3.47.1 

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

func (NatRuleArrayOutput) ToNatRuleArrayOutput added in v3.47.1 

func (o NatRuleArrayOutput) ToNatRuleArrayOutput() NatRuleArrayOutput

func (NatRuleArrayOutput) ToNatRuleArrayOutputWithContext added in v3.47.1 

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

type NatRuleInput added in v3.31.1 

type NatRuleInput interface {
	pulumi.Input

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

type NatRuleMap added in v3.47.1 

type NatRuleMap map[string]NatRuleInput

func (NatRuleMap) ElementType added in v3.47.1 

func (NatRuleMap) ElementType() reflect.Type

func (NatRuleMap) ToNatRuleMapOutput added in v3.47.1 

func (i NatRuleMap) ToNatRuleMapOutput() NatRuleMapOutput

func (NatRuleMap) ToNatRuleMapOutputWithContext added in v3.47.1 

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

type NatRuleMapInput added in v3.47.1 

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 added in v3.47.1 

type NatRuleMapOutput struct{ *pulumi.OutputState }

func (NatRuleMapOutput) ElementType added in v3.47.1 

func (NatRuleMapOutput) ElementType() reflect.Type

func (NatRuleMapOutput) MapIndex added in v3.47.1 

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

func (NatRuleMapOutput) ToNatRuleMapOutput added in v3.47.1 

func (o NatRuleMapOutput) ToNatRuleMapOutput() NatRuleMapOutput

func (NatRuleMapOutput) ToNatRuleMapOutputWithContext added in v3.47.1 

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

type NatRuleOutput added in v3.31.1 

type NatRuleOutput struct {
	*pulumi.OutputState
}

func (NatRuleOutput) ElementType added in v3.31.1 

func (NatRuleOutput) ElementType() reflect.Type

func (NatRuleOutput) ToNatRuleOutput added in v3.31.1 

func (o NatRuleOutput) ToNatRuleOutput() NatRuleOutput

func (NatRuleOutput) ToNatRuleOutputWithContext added in v3.31.1 

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

func (NatRuleOutput) ToNatRulePtrOutput added in v3.47.1 

func (o NatRuleOutput) ToNatRulePtrOutput() NatRulePtrOutput

func (NatRuleOutput) ToNatRulePtrOutputWithContext added in v3.47.1 

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

type NatRulePtrInput added in v3.47.1 

type NatRulePtrInput interface {
	pulumi.Input

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

type NatRulePtrOutput added in v3.47.1 

type NatRulePtrOutput struct {
	*pulumi.OutputState
}

func (NatRulePtrOutput) ElementType added in v3.47.1 

func (NatRulePtrOutput) ElementType() reflect.Type

func (NatRulePtrOutput) ToNatRulePtrOutput added in v3.47.1 

func (o NatRulePtrOutput) ToNatRulePtrOutput() NatRulePtrOutput

func (NatRulePtrOutput) ToNatRulePtrOutputWithContext added in v3.47.1 

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/v3/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/lb"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/network"
"github.com/pulumi/pulumi/sdk/v2/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 added in v3.31.1 

func (*OutboundRule) ElementType() reflect.Type

func (*OutboundRule) ToOutboundRuleOutput added in v3.31.1 

func (i *OutboundRule) ToOutboundRuleOutput() OutboundRuleOutput

func (*OutboundRule) ToOutboundRuleOutputWithContext added in v3.31.1 

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

func (*OutboundRule) ToOutboundRulePtrOutput added in v3.47.1 

func (i *OutboundRule) ToOutboundRulePtrOutput() OutboundRulePtrOutput

func (*OutboundRule) ToOutboundRulePtrOutputWithContext added in v3.47.1 

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 added in v3.47.1 

type OutboundRuleArray []OutboundRuleInput

func (OutboundRuleArray) ElementType added in v3.47.1 

func (OutboundRuleArray) ElementType() reflect.Type

func (OutboundRuleArray) ToOutboundRuleArrayOutput added in v3.47.1 

func (i OutboundRuleArray) ToOutboundRuleArrayOutput() OutboundRuleArrayOutput

func (OutboundRuleArray) ToOutboundRuleArrayOutputWithContext added in v3.47.1 

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

type OutboundRuleArrayInput added in v3.47.1 

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 added in v3.47.1 

type OutboundRuleArrayOutput struct{ *pulumi.OutputState }

func (OutboundRuleArrayOutput) ElementType added in v3.47.1 

func (OutboundRuleArrayOutput) ElementType() reflect.Type

func (OutboundRuleArrayOutput) Index added in v3.47.1 

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

func (OutboundRuleArrayOutput) ToOutboundRuleArrayOutput added in v3.47.1 

func (o OutboundRuleArrayOutput) ToOutboundRuleArrayOutput() OutboundRuleArrayOutput

func (OutboundRuleArrayOutput) ToOutboundRuleArrayOutputWithContext added in v3.47.1 

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 added in v3.31.1 

type OutboundRuleInput interface {
	pulumi.Input

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

type OutboundRuleMap added in v3.47.1 

type OutboundRuleMap map[string]OutboundRuleInput

func (OutboundRuleMap) ElementType added in v3.47.1 

func (OutboundRuleMap) ElementType() reflect.Type

func (OutboundRuleMap) ToOutboundRuleMapOutput added in v3.47.1 

func (i OutboundRuleMap) ToOutboundRuleMapOutput() OutboundRuleMapOutput

func (OutboundRuleMap) ToOutboundRuleMapOutputWithContext added in v3.47.1 

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

type OutboundRuleMapInput added in v3.47.1 

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 added in v3.47.1 

type OutboundRuleMapOutput struct{ *pulumi.OutputState }

func (OutboundRuleMapOutput) ElementType added in v3.47.1 

func (OutboundRuleMapOutput) ElementType() reflect.Type

func (OutboundRuleMapOutput) MapIndex added in v3.47.1 

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

func (OutboundRuleMapOutput) ToOutboundRuleMapOutput added in v3.47.1 

func (o OutboundRuleMapOutput) ToOutboundRuleMapOutput() OutboundRuleMapOutput

func (OutboundRuleMapOutput) ToOutboundRuleMapOutputWithContext added in v3.47.1 

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

type OutboundRuleOutput added in v3.31.1 

type OutboundRuleOutput struct {
	*pulumi.OutputState
}

func (OutboundRuleOutput) ElementType added in v3.31.1 

func (OutboundRuleOutput) ElementType() reflect.Type

func (OutboundRuleOutput) ToOutboundRuleOutput added in v3.31.1 

func (o OutboundRuleOutput) ToOutboundRuleOutput() OutboundRuleOutput

func (OutboundRuleOutput) ToOutboundRuleOutputWithContext added in v3.31.1 

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

func (OutboundRuleOutput) ToOutboundRulePtrOutput added in v3.47.1 

func (o OutboundRuleOutput) ToOutboundRulePtrOutput() OutboundRulePtrOutput

func (OutboundRuleOutput) ToOutboundRulePtrOutputWithContext added in v3.47.1 

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

type OutboundRulePtrInput added in v3.47.1 

type OutboundRulePtrInput interface {
	pulumi.Input

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

type OutboundRulePtrOutput added in v3.47.1 

type OutboundRulePtrOutput struct {
	*pulumi.OutputState
}

func (OutboundRulePtrOutput) ElementType added in v3.47.1 

func (OutboundRulePtrOutput) ElementType() reflect.Type

func (OutboundRulePtrOutput) ToOutboundRulePtrOutput added in v3.47.1 

func (o OutboundRulePtrOutput) ToOutboundRulePtrOutput() OutboundRulePtrOutput

func (OutboundRulePtrOutput) ToOutboundRulePtrOutputWithContext added in v3.47.1 

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/v3/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/lb"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/network"
"github.com/pulumi/pulumi/sdk/v2/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 added in v3.31.1 

func (*Probe) ElementType() reflect.Type

func (*Probe) ToProbeOutput added in v3.31.1 

func (i *Probe) ToProbeOutput() ProbeOutput

func (*Probe) ToProbeOutputWithContext added in v3.31.1 

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

func (*Probe) ToProbePtrOutput added in v3.47.1 

func (i *Probe) ToProbePtrOutput() ProbePtrOutput

func (*Probe) ToProbePtrOutputWithContext added in v3.47.1 

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 added in v3.47.1 

type ProbeArray []ProbeInput

func (ProbeArray) ElementType added in v3.47.1 

func (ProbeArray) ElementType() reflect.Type

func (ProbeArray) ToProbeArrayOutput added in v3.47.1 

func (i ProbeArray) ToProbeArrayOutput() ProbeArrayOutput

func (ProbeArray) ToProbeArrayOutputWithContext added in v3.47.1 

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

type ProbeArrayInput added in v3.47.1 

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 added in v3.47.1 

type ProbeArrayOutput struct{ *pulumi.OutputState }

func (ProbeArrayOutput) ElementType added in v3.47.1 

func (ProbeArrayOutput) ElementType() reflect.Type

func (ProbeArrayOutput) Index added in v3.47.1 

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

func (ProbeArrayOutput) ToProbeArrayOutput added in v3.47.1 

func (o ProbeArrayOutput) ToProbeArrayOutput() ProbeArrayOutput

func (ProbeArrayOutput) ToProbeArrayOutputWithContext added in v3.47.1 

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

type ProbeInput added in v3.31.1 

type ProbeInput interface {
	pulumi.Input

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

type ProbeMap added in v3.47.1 

type ProbeMap map[string]ProbeInput

func (ProbeMap) ElementType added in v3.47.1 

func (ProbeMap) ElementType() reflect.Type

func (ProbeMap) ToProbeMapOutput added in v3.47.1 

func (i ProbeMap) ToProbeMapOutput() ProbeMapOutput

func (ProbeMap) ToProbeMapOutputWithContext added in v3.47.1 

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

type ProbeMapInput added in v3.47.1 

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 added in v3.47.1 

type ProbeMapOutput struct{ *pulumi.OutputState }

func (ProbeMapOutput) ElementType added in v3.47.1 

func (ProbeMapOutput) ElementType() reflect.Type

func (ProbeMapOutput) MapIndex added in v3.47.1 

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

func (ProbeMapOutput) ToProbeMapOutput added in v3.47.1 

func (o ProbeMapOutput) ToProbeMapOutput() ProbeMapOutput

func (ProbeMapOutput) ToProbeMapOutputWithContext added in v3.47.1 

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

type ProbeOutput added in v3.31.1 

type ProbeOutput struct {
	*pulumi.OutputState
}

func (ProbeOutput) ElementType added in v3.31.1 

func (ProbeOutput) ElementType() reflect.Type

func (ProbeOutput) ToProbeOutput added in v3.31.1 

func (o ProbeOutput) ToProbeOutput() ProbeOutput

func (ProbeOutput) ToProbeOutputWithContext added in v3.31.1 

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

func (ProbeOutput) ToProbePtrOutput added in v3.47.1 

func (o ProbeOutput) ToProbePtrOutput() ProbePtrOutput

func (ProbeOutput) ToProbePtrOutputWithContext added in v3.47.1 

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

type ProbePtrInput added in v3.47.1 

type ProbePtrInput interface {
	pulumi.Input

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

type ProbePtrOutput added in v3.47.1 

type ProbePtrOutput struct {
	*pulumi.OutputState
}

func (ProbePtrOutput) ElementType added in v3.47.1 

func (ProbePtrOutput) ElementType() reflect.Type

func (ProbePtrOutput) ToProbePtrOutput added in v3.47.1 

func (o ProbePtrOutput) ToProbePtrOutput() ProbePtrOutput

func (ProbePtrOutput) ToProbePtrOutputWithContext added in v3.47.1 

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/v3/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/lb"
"github.com/pulumi/pulumi-azure/sdk/v3/go/azure/network"
"github.com/pulumi/pulumi/sdk/v2/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 added in v3.31.1 

func (*Rule) ElementType() reflect.Type

func (*Rule) ToRuleOutput added in v3.31.1 

func (i *Rule) ToRuleOutput() RuleOutput

func (*Rule) ToRuleOutputWithContext added in v3.31.1 

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

func (*Rule) ToRulePtrOutput added in v3.47.1 

func (i *Rule) ToRulePtrOutput() RulePtrOutput

func (*Rule) ToRulePtrOutputWithContext added in v3.47.1 

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 added in v3.47.1 

type RuleArray []RuleInput

func (RuleArray) ElementType added in v3.47.1 

func (RuleArray) ElementType() reflect.Type

func (RuleArray) ToRuleArrayOutput added in v3.47.1 

func (i RuleArray) ToRuleArrayOutput() RuleArrayOutput

func (RuleArray) ToRuleArrayOutputWithContext added in v3.47.1 

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

type RuleArrayInput added in v3.47.1 

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 added in v3.47.1 

type RuleArrayOutput struct{ *pulumi.OutputState }

func (RuleArrayOutput) ElementType added in v3.47.1 

func (RuleArrayOutput) ElementType() reflect.Type

func (RuleArrayOutput) Index added in v3.47.1 

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

func (RuleArrayOutput) ToRuleArrayOutput added in v3.47.1 

func (o RuleArrayOutput) ToRuleArrayOutput() RuleArrayOutput

func (RuleArrayOutput) ToRuleArrayOutputWithContext added in v3.47.1 

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

type RuleInput added in v3.31.1 

type RuleInput interface {
	pulumi.Input

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

type RuleMap added in v3.47.1 

type RuleMap map[string]RuleInput

func (RuleMap) ElementType added in v3.47.1 

func (RuleMap) ElementType() reflect.Type

func (RuleMap) ToRuleMapOutput added in v3.47.1 

func (i RuleMap) ToRuleMapOutput() RuleMapOutput

func (RuleMap) ToRuleMapOutputWithContext added in v3.47.1 

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

type RuleMapInput added in v3.47.1 

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 added in v3.47.1 

type RuleMapOutput struct{ *pulumi.OutputState }

func (RuleMapOutput) ElementType added in v3.47.1 

func (RuleMapOutput) ElementType() reflect.Type

func (RuleMapOutput) MapIndex added in v3.47.1 

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

func (RuleMapOutput) ToRuleMapOutput added in v3.47.1 

func (o RuleMapOutput) ToRuleMapOutput() RuleMapOutput

func (RuleMapOutput) ToRuleMapOutputWithContext added in v3.47.1 

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

type RuleOutput added in v3.31.1 

type RuleOutput struct {
	*pulumi.OutputState
}

func (RuleOutput) ElementType added in v3.31.1 

func (RuleOutput) ElementType() reflect.Type

func (RuleOutput) ToRuleOutput added in v3.31.1 

func (o RuleOutput) ToRuleOutput() RuleOutput

func (RuleOutput) ToRuleOutputWithContext added in v3.31.1 

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

func (RuleOutput) ToRulePtrOutput added in v3.47.1 

func (o RuleOutput) ToRulePtrOutput() RulePtrOutput

func (RuleOutput) ToRulePtrOutputWithContext added in v3.47.1 

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

type RulePtrInput added in v3.47.1 

type RulePtrInput interface {
	pulumi.Input

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

type RulePtrOutput added in v3.47.1 

type RulePtrOutput struct {
	*pulumi.OutputState
}

func (RulePtrOutput) ElementType added in v3.47.1 

func (RulePtrOutput) ElementType() reflect.Type

func (RulePtrOutput) ToRulePtrOutput added in v3.47.1 

func (o RulePtrOutput) ToRulePtrOutput() RulePtrOutput

func (RulePtrOutput) ToRulePtrOutputWithContext added in v3.47.1 

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.