lb

package
v5.83.0 Latest Latest
Warning

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

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

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type BackendAddressPool 

type BackendAddressPool struct {
	pulumi.CustomResourceState

	// The Backend IP Configurations associated with this Backend Address Pool.
	BackendIpConfigurations pulumi.StringArrayOutput `pulumi:"backendIpConfigurations"`
	// An array of the Load Balancing Inbound NAT Rules associated with this Backend Address Pool.
	InboundNatRules pulumi.StringArrayOutput `pulumi:"inboundNatRules"`
	// 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. Changing this forces a new resource to be created.
	LoadbalancerId pulumi.StringOutput `pulumi:"loadbalancerId"`
	// Specifies the name of the Backend Address Pool. Changing this forces a new resource to be created.
	Name pulumi.StringOutput `pulumi:"name"`
	// An array of the Load Balancing Outbound Rules associated with this Backend Address Pool.
	OutboundRules pulumi.StringArrayOutput `pulumi:"outboundRules"`
	// The backend address synchronous mode for the Backend Address Pool. Possible values are `Automatic` and `Manual`. This is required with `virtualNetworkId`. Changing this forces a new resource to be created.
	//
	// > **NOTE:** The `synchronousMode` can set only for Load Balancer with `Standard` SKU.
	SynchronousMode pulumi.StringPtrOutput `pulumi:"synchronousMode"`
	// One or more `tunnelInterface` blocks as defined below.
	TunnelInterfaces BackendAddressPoolTunnelInterfaceArrayOutput `pulumi:"tunnelInterfaces"`
	// The ID of the Virtual Network within which the Backend Address Pool should exist.
	VirtualNetworkId pulumi.StringPtrOutput `pulumi:"virtualNetworkId"`
}

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

) 

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

```

## Import

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

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

func GetBackendAddressPool 

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

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

func NewBackendAddressPool 

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

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

func (*BackendAddressPool) ElementType 

func (*BackendAddressPool) ElementType() reflect.Type

func (*BackendAddressPool) ToBackendAddressPoolOutput 

func (i *BackendAddressPool) ToBackendAddressPoolOutput() BackendAddressPoolOutput

func (*BackendAddressPool) ToBackendAddressPoolOutputWithContext 

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

type BackendAddressPoolAddress 

type BackendAddressPoolAddress struct {
	pulumi.CustomResourceState

	// The ip config ID of the regional load balancer that's added to the global load balancer's backend address pool.
	//
	// > **Note:** For cross-region load balancer, please append the name of the load balancers, virtual machines, and other resources in each region with a -R1 and -R2.
	BackendAddressIpConfigurationId pulumi.StringPtrOutput `pulumi:"backendAddressIpConfigurationId"`
	// The ID of the Backend Address Pool. Changing this forces a new Backend Address Pool Address to be created.
	BackendAddressPoolId pulumi.StringOutput `pulumi:"backendAddressPoolId"`
	// A list of `inboundNatRulePortMapping` block as defined below.
	InboundNatRulePortMappings BackendAddressPoolAddressInboundNatRulePortMappingArrayOutput `pulumi:"inboundNatRulePortMappings"`
	// The Static IP Address which should be allocated to this Backend Address Pool.
	IpAddress pulumi.StringPtrOutput `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.StringPtrOutput `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/v5/go/azure/lb"
"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/network"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := network.LookupVirtualNetwork(ctx, &network.LookupVirtualNetworkArgs{
			Name:              "example-network",
			ResourceGroupName: "example-resources",
		}, nil)
		if err != nil {
			return err
		}
		exampleGetLB, err := lb.GetLB(ctx, &lb.GetLBArgs{
			Name:              "example-lb",
			ResourceGroupName: "example-resources",
		}, nil)
		if err != nil {
			return err
		}
		exampleGetBackendAddressPool, err := lb.LookupBackendAddressPool(ctx, &lb.LookupBackendAddressPoolArgs{
			Name:           "first",
			LoadbalancerId: exampleGetLB.Id,
		}, nil)
		if err != nil {
			return err
		}
		_, err = lb.NewBackendAddressPoolAddress(ctx, "example", &lb.BackendAddressPoolAddressArgs{
			Name:                 pulumi.String("example"),
			BackendAddressPoolId: pulumi.String(exampleGetBackendAddressPool.Id),
			VirtualNetworkId:     pulumi.String(example.Id),
			IpAddress:            pulumi.String("10.0.0.1"),
		})
		if err != nil {
			return err
		}
		backend_pool_cr, err := lb.LookupBackendAddressPool(ctx, &lb.LookupBackendAddressPoolArgs{
			Name:           "globalLBBackendPool",
			LoadbalancerId: exampleGetLB.Id,
		}, nil)
		if err != nil {
			return err
		}
		_, err = lb.NewBackendAddressPoolAddress(ctx, "example-1", &lb.BackendAddressPoolAddressArgs{
			Name:                            pulumi.String("address1"),
			BackendAddressPoolId:            pulumi.String(backend_pool_cr.Id),
			BackendAddressIpConfigurationId: pulumi.Any(backend_lb_R1.FrontendIpConfiguration[0].Id),
		})
		if err != nil {
			return err
		}
		_, err = lb.NewBackendAddressPoolAddress(ctx, "example-2", &lb.BackendAddressPoolAddressArgs{
			Name:                            pulumi.String("address2"),
			BackendAddressPoolId:            pulumi.String(backend_pool_cr.Id),
			BackendAddressIpConfigurationId: pulumi.Any(backend_lb_R2.FrontendIpConfiguration[0].Id),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

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

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

func GetBackendAddressPoolAddress 

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

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

func NewBackendAddressPoolAddress 

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

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

func (*BackendAddressPoolAddress) ElementType 

func (*BackendAddressPoolAddress) ElementType() reflect.Type

func (*BackendAddressPoolAddress) ToBackendAddressPoolAddressOutput 

func (i *BackendAddressPoolAddress) ToBackendAddressPoolAddressOutput() BackendAddressPoolAddressOutput

func (*BackendAddressPoolAddress) ToBackendAddressPoolAddressOutputWithContext 

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

type BackendAddressPoolAddressArgs 

type BackendAddressPoolAddressArgs struct {
	// The ip config ID of the regional load balancer that's added to the global load balancer's backend address pool.
	//
	// > **Note:** For cross-region load balancer, please append the name of the load balancers, virtual machines, and other resources in each region with a -R1 and -R2.
	BackendAddressIpConfigurationId pulumi.StringPtrInput
	// 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.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
}

The set of arguments for constructing a BackendAddressPoolAddress resource.

func (BackendAddressPoolAddressArgs) ElementType 

func (BackendAddressPoolAddressArgs) ElementType() reflect.Type

type BackendAddressPoolAddressArray 

type BackendAddressPoolAddressArray []BackendAddressPoolAddressInput

func (BackendAddressPoolAddressArray) ElementType 

func (BackendAddressPoolAddressArray) ElementType() reflect.Type

func (BackendAddressPoolAddressArray) ToBackendAddressPoolAddressArrayOutput 

func (i BackendAddressPoolAddressArray) ToBackendAddressPoolAddressArrayOutput() BackendAddressPoolAddressArrayOutput

func (BackendAddressPoolAddressArray) ToBackendAddressPoolAddressArrayOutputWithContext 

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

type BackendAddressPoolAddressArrayInput 

type BackendAddressPoolAddressArrayInput interface {
	pulumi.Input

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

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

BackendAddressPoolAddressArray{ BackendAddressPoolAddressArgs{...} }

type BackendAddressPoolAddressArrayOutput 

type BackendAddressPoolAddressArrayOutput struct{ *pulumi.OutputState }

func (BackendAddressPoolAddressArrayOutput) ElementType 

func (BackendAddressPoolAddressArrayOutput) ElementType() reflect.Type

func (BackendAddressPoolAddressArrayOutput) Index 

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

func (BackendAddressPoolAddressArrayOutput) ToBackendAddressPoolAddressArrayOutput 

func (o BackendAddressPoolAddressArrayOutput) ToBackendAddressPoolAddressArrayOutput() BackendAddressPoolAddressArrayOutput

func (BackendAddressPoolAddressArrayOutput) ToBackendAddressPoolAddressArrayOutputWithContext 

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

type BackendAddressPoolAddressInboundNatRulePortMapping added in v5.12.0 

type BackendAddressPoolAddressInboundNatRulePortMapping struct {
	// The Backend Port of the Load Balancing Inbound NAT Rules associated with this Backend Address Pool Address.
	BackendPort *int `pulumi:"backendPort"`
	// The Frontend Port of the Load Balancing Inbound NAT Rules associated with this Backend Address Pool Address.
	FrontendPort *int `pulumi:"frontendPort"`
	// The name of the Load Balancing Inbound NAT Rules associated with this Backend Address Pool Address.
	InboundNatRuleName *string `pulumi:"inboundNatRuleName"`
}

type BackendAddressPoolAddressInboundNatRulePortMappingArgs added in v5.12.0 

type BackendAddressPoolAddressInboundNatRulePortMappingArgs struct {
	// The Backend Port of the Load Balancing Inbound NAT Rules associated with this Backend Address Pool Address.
	BackendPort pulumi.IntPtrInput `pulumi:"backendPort"`
	// The Frontend Port of the Load Balancing Inbound NAT Rules associated with this Backend Address Pool Address.
	FrontendPort pulumi.IntPtrInput `pulumi:"frontendPort"`
	// The name of the Load Balancing Inbound NAT Rules associated with this Backend Address Pool Address.
	InboundNatRuleName pulumi.StringPtrInput `pulumi:"inboundNatRuleName"`
}

func (BackendAddressPoolAddressInboundNatRulePortMappingArgs) ElementType added in v5.12.0 

func (BackendAddressPoolAddressInboundNatRulePortMappingArgs) ElementType() reflect.Type

func (BackendAddressPoolAddressInboundNatRulePortMappingArgs) ToBackendAddressPoolAddressInboundNatRulePortMappingOutput added in v5.12.0 

func (i BackendAddressPoolAddressInboundNatRulePortMappingArgs) ToBackendAddressPoolAddressInboundNatRulePortMappingOutput() BackendAddressPoolAddressInboundNatRulePortMappingOutput

func (BackendAddressPoolAddressInboundNatRulePortMappingArgs) ToBackendAddressPoolAddressInboundNatRulePortMappingOutputWithContext added in v5.12.0 

func (i BackendAddressPoolAddressInboundNatRulePortMappingArgs) ToBackendAddressPoolAddressInboundNatRulePortMappingOutputWithContext(ctx context.Context) BackendAddressPoolAddressInboundNatRulePortMappingOutput

type BackendAddressPoolAddressInboundNatRulePortMappingArray added in v5.12.0 

type BackendAddressPoolAddressInboundNatRulePortMappingArray []BackendAddressPoolAddressInboundNatRulePortMappingInput

func (BackendAddressPoolAddressInboundNatRulePortMappingArray) ElementType added in v5.12.0 

func (BackendAddressPoolAddressInboundNatRulePortMappingArray) ElementType() reflect.Type

func (BackendAddressPoolAddressInboundNatRulePortMappingArray) ToBackendAddressPoolAddressInboundNatRulePortMappingArrayOutput added in v5.12.0 

func (i BackendAddressPoolAddressInboundNatRulePortMappingArray) ToBackendAddressPoolAddressInboundNatRulePortMappingArrayOutput() BackendAddressPoolAddressInboundNatRulePortMappingArrayOutput

func (BackendAddressPoolAddressInboundNatRulePortMappingArray) ToBackendAddressPoolAddressInboundNatRulePortMappingArrayOutputWithContext added in v5.12.0 

func (i BackendAddressPoolAddressInboundNatRulePortMappingArray) ToBackendAddressPoolAddressInboundNatRulePortMappingArrayOutputWithContext(ctx context.Context) BackendAddressPoolAddressInboundNatRulePortMappingArrayOutput

type BackendAddressPoolAddressInboundNatRulePortMappingArrayInput added in v5.12.0 

type BackendAddressPoolAddressInboundNatRulePortMappingArrayInput interface {
	pulumi.Input

	ToBackendAddressPoolAddressInboundNatRulePortMappingArrayOutput() BackendAddressPoolAddressInboundNatRulePortMappingArrayOutput
	ToBackendAddressPoolAddressInboundNatRulePortMappingArrayOutputWithContext(context.Context) BackendAddressPoolAddressInboundNatRulePortMappingArrayOutput
}

BackendAddressPoolAddressInboundNatRulePortMappingArrayInput is an input type that accepts BackendAddressPoolAddressInboundNatRulePortMappingArray and BackendAddressPoolAddressInboundNatRulePortMappingArrayOutput values. You can construct a concrete instance of `BackendAddressPoolAddressInboundNatRulePortMappingArrayInput` via: 

BackendAddressPoolAddressInboundNatRulePortMappingArray{ BackendAddressPoolAddressInboundNatRulePortMappingArgs{...} }

type BackendAddressPoolAddressInboundNatRulePortMappingArrayOutput added in v5.12.0 

type BackendAddressPoolAddressInboundNatRulePortMappingArrayOutput struct{ *pulumi.OutputState }

func (BackendAddressPoolAddressInboundNatRulePortMappingArrayOutput) ElementType added in v5.12.0 

func (BackendAddressPoolAddressInboundNatRulePortMappingArrayOutput) ElementType() reflect.Type

func (BackendAddressPoolAddressInboundNatRulePortMappingArrayOutput) Index added in v5.12.0 

func (o BackendAddressPoolAddressInboundNatRulePortMappingArrayOutput) Index(i pulumi.IntInput) BackendAddressPoolAddressInboundNatRulePortMappingOutput

func (BackendAddressPoolAddressInboundNatRulePortMappingArrayOutput) ToBackendAddressPoolAddressInboundNatRulePortMappingArrayOutput added in v5.12.0 

func (o BackendAddressPoolAddressInboundNatRulePortMappingArrayOutput) ToBackendAddressPoolAddressInboundNatRulePortMappingArrayOutput() BackendAddressPoolAddressInboundNatRulePortMappingArrayOutput

func (BackendAddressPoolAddressInboundNatRulePortMappingArrayOutput) ToBackendAddressPoolAddressInboundNatRulePortMappingArrayOutputWithContext added in v5.12.0 

func (o BackendAddressPoolAddressInboundNatRulePortMappingArrayOutput) ToBackendAddressPoolAddressInboundNatRulePortMappingArrayOutputWithContext(ctx context.Context) BackendAddressPoolAddressInboundNatRulePortMappingArrayOutput

type BackendAddressPoolAddressInboundNatRulePortMappingInput added in v5.12.0 

type BackendAddressPoolAddressInboundNatRulePortMappingInput interface {
	pulumi.Input

	ToBackendAddressPoolAddressInboundNatRulePortMappingOutput() BackendAddressPoolAddressInboundNatRulePortMappingOutput
	ToBackendAddressPoolAddressInboundNatRulePortMappingOutputWithContext(context.Context) BackendAddressPoolAddressInboundNatRulePortMappingOutput
}

BackendAddressPoolAddressInboundNatRulePortMappingInput is an input type that accepts BackendAddressPoolAddressInboundNatRulePortMappingArgs and BackendAddressPoolAddressInboundNatRulePortMappingOutput values. You can construct a concrete instance of `BackendAddressPoolAddressInboundNatRulePortMappingInput` via: 

BackendAddressPoolAddressInboundNatRulePortMappingArgs{...}

type BackendAddressPoolAddressInboundNatRulePortMappingOutput added in v5.12.0 

type BackendAddressPoolAddressInboundNatRulePortMappingOutput struct{ *pulumi.OutputState }

func (BackendAddressPoolAddressInboundNatRulePortMappingOutput) BackendPort added in v5.12.0 

func (o BackendAddressPoolAddressInboundNatRulePortMappingOutput) BackendPort() pulumi.IntPtrOutput

The Backend Port of the Load Balancing Inbound NAT Rules associated with this Backend Address Pool Address.

func (BackendAddressPoolAddressInboundNatRulePortMappingOutput) ElementType added in v5.12.0 

func (BackendAddressPoolAddressInboundNatRulePortMappingOutput) ElementType() reflect.Type

func (BackendAddressPoolAddressInboundNatRulePortMappingOutput) FrontendPort added in v5.12.0 

func (o BackendAddressPoolAddressInboundNatRulePortMappingOutput) FrontendPort() pulumi.IntPtrOutput

The Frontend Port of the Load Balancing Inbound NAT Rules associated with this Backend Address Pool Address.

func (BackendAddressPoolAddressInboundNatRulePortMappingOutput) InboundNatRuleName added in v5.12.0 

func (o BackendAddressPoolAddressInboundNatRulePortMappingOutput) InboundNatRuleName() pulumi.StringPtrOutput

The name of the Load Balancing Inbound NAT Rules associated with this Backend Address Pool Address.

func (BackendAddressPoolAddressInboundNatRulePortMappingOutput) ToBackendAddressPoolAddressInboundNatRulePortMappingOutput added in v5.12.0 

func (o BackendAddressPoolAddressInboundNatRulePortMappingOutput) ToBackendAddressPoolAddressInboundNatRulePortMappingOutput() BackendAddressPoolAddressInboundNatRulePortMappingOutput

func (BackendAddressPoolAddressInboundNatRulePortMappingOutput) ToBackendAddressPoolAddressInboundNatRulePortMappingOutputWithContext added in v5.12.0 

func (o BackendAddressPoolAddressInboundNatRulePortMappingOutput) ToBackendAddressPoolAddressInboundNatRulePortMappingOutputWithContext(ctx context.Context) BackendAddressPoolAddressInboundNatRulePortMappingOutput

type BackendAddressPoolAddressInput 

type BackendAddressPoolAddressInput interface {
	pulumi.Input

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

type BackendAddressPoolAddressMap 

type BackendAddressPoolAddressMap map[string]BackendAddressPoolAddressInput

func (BackendAddressPoolAddressMap) ElementType 

func (BackendAddressPoolAddressMap) ElementType() reflect.Type

func (BackendAddressPoolAddressMap) ToBackendAddressPoolAddressMapOutput 

func (i BackendAddressPoolAddressMap) ToBackendAddressPoolAddressMapOutput() BackendAddressPoolAddressMapOutput

func (BackendAddressPoolAddressMap) ToBackendAddressPoolAddressMapOutputWithContext 

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

type BackendAddressPoolAddressMapInput 

type BackendAddressPoolAddressMapInput interface {
	pulumi.Input

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

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

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

type BackendAddressPoolAddressMapOutput 

type BackendAddressPoolAddressMapOutput struct{ *pulumi.OutputState }

func (BackendAddressPoolAddressMapOutput) ElementType 

func (BackendAddressPoolAddressMapOutput) ElementType() reflect.Type

func (BackendAddressPoolAddressMapOutput) MapIndex 

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

func (BackendAddressPoolAddressMapOutput) ToBackendAddressPoolAddressMapOutput 

func (o BackendAddressPoolAddressMapOutput) ToBackendAddressPoolAddressMapOutput() BackendAddressPoolAddressMapOutput

func (BackendAddressPoolAddressMapOutput) ToBackendAddressPoolAddressMapOutputWithContext 

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

type BackendAddressPoolAddressOutput 

type BackendAddressPoolAddressOutput struct{ *pulumi.OutputState }

func (BackendAddressPoolAddressOutput) BackendAddressIpConfigurationId added in v5.16.0 

func (o BackendAddressPoolAddressOutput) BackendAddressIpConfigurationId() pulumi.StringPtrOutput

The ip config ID of the regional load balancer that's added to the global load balancer's backend address pool.

> **Note:** For cross-region load balancer, please append the name of the load balancers, virtual machines, and other resources in each region with a -R1 and -R2.

func (BackendAddressPoolAddressOutput) BackendAddressPoolId added in v5.5.0 

func (o BackendAddressPoolAddressOutput) BackendAddressPoolId() pulumi.StringOutput

The ID of the Backend Address Pool. Changing this forces a new Backend Address Pool Address to be created.

func (BackendAddressPoolAddressOutput) ElementType 

func (BackendAddressPoolAddressOutput) ElementType() reflect.Type

func (BackendAddressPoolAddressOutput) InboundNatRulePortMappings added in v5.12.0 

func (o BackendAddressPoolAddressOutput) InboundNatRulePortMappings() BackendAddressPoolAddressInboundNatRulePortMappingArrayOutput

A list of `inboundNatRulePortMapping` block as defined below.

func (BackendAddressPoolAddressOutput) IpAddress added in v5.5.0 

func (o BackendAddressPoolAddressOutput) IpAddress() pulumi.StringPtrOutput

The Static IP Address which should be allocated to this Backend Address Pool.

func (BackendAddressPoolAddressOutput) Name added in v5.5.0 

func (o BackendAddressPoolAddressOutput) Name() pulumi.StringOutput

The name which should be used for this Backend Address Pool Address. Changing this forces a new Backend Address Pool Address to be created.

func (BackendAddressPoolAddressOutput) ToBackendAddressPoolAddressOutput 

func (o BackendAddressPoolAddressOutput) ToBackendAddressPoolAddressOutput() BackendAddressPoolAddressOutput

func (BackendAddressPoolAddressOutput) ToBackendAddressPoolAddressOutputWithContext 

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

func (BackendAddressPoolAddressOutput) VirtualNetworkId added in v5.5.0 

func (o BackendAddressPoolAddressOutput) VirtualNetworkId() pulumi.StringPtrOutput

The ID of the Virtual Network within which the Backend Address Pool should exist.

type BackendAddressPoolAddressState 

type BackendAddressPoolAddressState struct {
	// The ip config ID of the regional load balancer that's added to the global load balancer's backend address pool.
	//
	// > **Note:** For cross-region load balancer, please append the name of the load balancers, virtual machines, and other resources in each region with a -R1 and -R2.
	BackendAddressIpConfigurationId pulumi.StringPtrInput
	// The ID of the Backend Address Pool. Changing this forces a new Backend Address Pool Address to be created.
	BackendAddressPoolId pulumi.StringPtrInput
	// A list of `inboundNatRulePortMapping` block as defined below.
	InboundNatRulePortMappings BackendAddressPoolAddressInboundNatRulePortMappingArrayInput
	// The Static IP Address which should be allocated to this Backend Address Pool.
	IpAddress pulumi.StringPtrInput
	// The name which should be used for this Backend Address Pool Address. Changing this forces a new Backend Address Pool Address to be created.
	Name pulumi.StringPtrInput
	// The ID of the Virtual Network within which the Backend Address Pool should exist.
	VirtualNetworkId pulumi.StringPtrInput
}

func (BackendAddressPoolAddressState) ElementType 

func (BackendAddressPoolAddressState) ElementType() reflect.Type

type BackendAddressPoolArgs 

type BackendAddressPoolArgs struct {
	// The ID of the Load Balancer in which to create the Backend Address Pool. Changing this forces a new resource to be created.
	LoadbalancerId pulumi.StringInput
	// Specifies the name of the Backend Address Pool. Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// The backend address synchronous mode for the Backend Address Pool. Possible values are `Automatic` and `Manual`. This is required with `virtualNetworkId`. Changing this forces a new resource to be created.
	//
	// > **NOTE:** The `synchronousMode` can set only for Load Balancer with `Standard` SKU.
	SynchronousMode pulumi.StringPtrInput
	// One or more `tunnelInterface` blocks as defined below.
	TunnelInterfaces BackendAddressPoolTunnelInterfaceArrayInput
	// The ID of the Virtual Network within which the Backend Address Pool should exist.
	VirtualNetworkId pulumi.StringPtrInput
}

The set of arguments for constructing a BackendAddressPool resource.

func (BackendAddressPoolArgs) ElementType 

func (BackendAddressPoolArgs) ElementType() reflect.Type

type BackendAddressPoolArray 

type BackendAddressPoolArray []BackendAddressPoolInput

func (BackendAddressPoolArray) ElementType 

func (BackendAddressPoolArray) ElementType() reflect.Type

func (BackendAddressPoolArray) ToBackendAddressPoolArrayOutput 

func (i BackendAddressPoolArray) ToBackendAddressPoolArrayOutput() BackendAddressPoolArrayOutput

func (BackendAddressPoolArray) ToBackendAddressPoolArrayOutputWithContext 

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

type BackendAddressPoolArrayInput 

type BackendAddressPoolArrayInput interface {
	pulumi.Input

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

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

BackendAddressPoolArray{ BackendAddressPoolArgs{...} }

type BackendAddressPoolArrayOutput 

type BackendAddressPoolArrayOutput struct{ *pulumi.OutputState }

func (BackendAddressPoolArrayOutput) ElementType 

func (BackendAddressPoolArrayOutput) ElementType() reflect.Type

func (BackendAddressPoolArrayOutput) Index 

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

func (BackendAddressPoolArrayOutput) ToBackendAddressPoolArrayOutput 

func (o BackendAddressPoolArrayOutput) ToBackendAddressPoolArrayOutput() BackendAddressPoolArrayOutput

func (BackendAddressPoolArrayOutput) ToBackendAddressPoolArrayOutputWithContext 

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

type BackendAddressPoolInput 

type BackendAddressPoolInput interface {
	pulumi.Input

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

type BackendAddressPoolMap 

type BackendAddressPoolMap map[string]BackendAddressPoolInput

func (BackendAddressPoolMap) ElementType 

func (BackendAddressPoolMap) ElementType() reflect.Type

func (BackendAddressPoolMap) ToBackendAddressPoolMapOutput 

func (i BackendAddressPoolMap) ToBackendAddressPoolMapOutput() BackendAddressPoolMapOutput

func (BackendAddressPoolMap) ToBackendAddressPoolMapOutputWithContext 

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

type BackendAddressPoolMapInput 

type BackendAddressPoolMapInput interface {
	pulumi.Input

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

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

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

type BackendAddressPoolMapOutput 

type BackendAddressPoolMapOutput struct{ *pulumi.OutputState }

func (BackendAddressPoolMapOutput) ElementType 

func (BackendAddressPoolMapOutput) ElementType() reflect.Type

func (BackendAddressPoolMapOutput) MapIndex 

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

func (BackendAddressPoolMapOutput) ToBackendAddressPoolMapOutput 

func (o BackendAddressPoolMapOutput) ToBackendAddressPoolMapOutput() BackendAddressPoolMapOutput

func (BackendAddressPoolMapOutput) ToBackendAddressPoolMapOutputWithContext 

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

type BackendAddressPoolOutput 

type BackendAddressPoolOutput struct{ *pulumi.OutputState }

func (BackendAddressPoolOutput) BackendIpConfigurations added in v5.5.0 

func (o BackendAddressPoolOutput) BackendIpConfigurations() pulumi.StringArrayOutput

The Backend IP Configurations associated with this Backend Address Pool.

func (BackendAddressPoolOutput) ElementType 

func (BackendAddressPoolOutput) ElementType() reflect.Type

func (BackendAddressPoolOutput) InboundNatRules added in v5.12.0 

func (o BackendAddressPoolOutput) InboundNatRules() pulumi.StringArrayOutput

An array of the Load Balancing Inbound NAT Rules associated with this Backend Address Pool.

func (BackendAddressPoolOutput) LoadBalancingRules added in v5.5.0 

func (o BackendAddressPoolOutput) LoadBalancingRules() pulumi.StringArrayOutput

The Load Balancing Rules associated with this Backend Address Pool.

func (BackendAddressPoolOutput) LoadbalancerId added in v5.5.0 

func (o BackendAddressPoolOutput) LoadbalancerId() pulumi.StringOutput

The ID of the Load Balancer in which to create the Backend Address Pool. Changing this forces a new resource to be created.

func (BackendAddressPoolOutput) Name added in v5.5.0 

func (o BackendAddressPoolOutput) Name() pulumi.StringOutput

Specifies the name of the Backend Address Pool. Changing this forces a new resource to be created.

func (BackendAddressPoolOutput) OutboundRules added in v5.5.0 

func (o BackendAddressPoolOutput) OutboundRules() pulumi.StringArrayOutput

An array of the Load Balancing Outbound Rules associated with this Backend Address Pool.

func (BackendAddressPoolOutput) SynchronousMode added in v5.81.0 

func (o BackendAddressPoolOutput) SynchronousMode() pulumi.StringPtrOutput

The backend address synchronous mode for the Backend Address Pool. Possible values are `Automatic` and `Manual`. This is required with `virtualNetworkId`. Changing this forces a new resource to be created.

> **NOTE:** The `synchronousMode` can set only for Load Balancer with `Standard` SKU.

func (BackendAddressPoolOutput) ToBackendAddressPoolOutput 

func (o BackendAddressPoolOutput) ToBackendAddressPoolOutput() BackendAddressPoolOutput

func (BackendAddressPoolOutput) ToBackendAddressPoolOutputWithContext 

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

func (BackendAddressPoolOutput) TunnelInterfaces added in v5.5.0 

func (o BackendAddressPoolOutput) TunnelInterfaces() BackendAddressPoolTunnelInterfaceArrayOutput

One or more `tunnelInterface` blocks as defined below.

func (BackendAddressPoolOutput) VirtualNetworkId added in v5.34.0 

func (o BackendAddressPoolOutput) VirtualNetworkId() pulumi.StringPtrOutput

The ID of the Virtual Network within which the Backend Address Pool should exist.

type BackendAddressPoolState 

type BackendAddressPoolState struct {
	// The Backend IP Configurations associated with this Backend Address Pool.
	BackendIpConfigurations pulumi.StringArrayInput
	// An array of the Load Balancing Inbound NAT Rules associated with this Backend Address Pool.
	InboundNatRules 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. Changing this forces a new resource to be created.
	LoadbalancerId pulumi.StringPtrInput
	// Specifies the name of the Backend Address Pool. Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// An array of the Load Balancing Outbound Rules associated with this Backend Address Pool.
	OutboundRules pulumi.StringArrayInput
	// The backend address synchronous mode for the Backend Address Pool. Possible values are `Automatic` and `Manual`. This is required with `virtualNetworkId`. Changing this forces a new resource to be created.
	//
	// > **NOTE:** The `synchronousMode` can set only for Load Balancer with `Standard` SKU.
	SynchronousMode pulumi.StringPtrInput
	// One or more `tunnelInterface` blocks as defined below.
	TunnelInterfaces BackendAddressPoolTunnelInterfaceArrayInput
	// The ID of the Virtual Network within which the Backend Address Pool should exist.
	VirtualNetworkId pulumi.StringPtrInput
}

func (BackendAddressPoolState) ElementType 

func (BackendAddressPoolState) ElementType() reflect.Type

type BackendAddressPoolTunnelInterface 

type BackendAddressPoolTunnelInterface struct {
	// The unique identifier of this Gateway Load Balancer Tunnel Interface.
	Identifier int `pulumi:"identifier"`
	// The port number that this Gateway Load Balancer Tunnel Interface listens to.
	Port int `pulumi:"port"`
	// The protocol used for this Gateway Load Balancer Tunnel Interface. Possible values are `None`, `Native` and `VXLAN`.
	Protocol string `pulumi:"protocol"`
	// The traffic type of this Gateway Load Balancer Tunnel Interface. Possible values are `None`, `Internal` and `External`.
	Type string `pulumi:"type"`
}

type BackendAddressPoolTunnelInterfaceArgs 

type BackendAddressPoolTunnelInterfaceArgs struct {
	// The unique identifier of this Gateway Load Balancer Tunnel Interface.
	Identifier pulumi.IntInput `pulumi:"identifier"`
	// The port number that this Gateway Load Balancer Tunnel Interface listens to.
	Port pulumi.IntInput `pulumi:"port"`
	// The protocol used for this Gateway Load Balancer Tunnel Interface. Possible values are `None`, `Native` and `VXLAN`.
	Protocol pulumi.StringInput `pulumi:"protocol"`
	// The traffic type of this Gateway Load Balancer Tunnel Interface. Possible values are `None`, `Internal` and `External`.
	Type pulumi.StringInput `pulumi:"type"`
}

func (BackendAddressPoolTunnelInterfaceArgs) ElementType 

func (BackendAddressPoolTunnelInterfaceArgs) ElementType() reflect.Type

func (BackendAddressPoolTunnelInterfaceArgs) ToBackendAddressPoolTunnelInterfaceOutput 

func (i BackendAddressPoolTunnelInterfaceArgs) ToBackendAddressPoolTunnelInterfaceOutput() BackendAddressPoolTunnelInterfaceOutput

func (BackendAddressPoolTunnelInterfaceArgs) ToBackendAddressPoolTunnelInterfaceOutputWithContext 

func (i BackendAddressPoolTunnelInterfaceArgs) ToBackendAddressPoolTunnelInterfaceOutputWithContext(ctx context.Context) BackendAddressPoolTunnelInterfaceOutput

type BackendAddressPoolTunnelInterfaceArray 

type BackendAddressPoolTunnelInterfaceArray []BackendAddressPoolTunnelInterfaceInput

func (BackendAddressPoolTunnelInterfaceArray) ElementType 

func (BackendAddressPoolTunnelInterfaceArray) ElementType() reflect.Type

func (BackendAddressPoolTunnelInterfaceArray) ToBackendAddressPoolTunnelInterfaceArrayOutput 

func (i BackendAddressPoolTunnelInterfaceArray) ToBackendAddressPoolTunnelInterfaceArrayOutput() BackendAddressPoolTunnelInterfaceArrayOutput

func (BackendAddressPoolTunnelInterfaceArray) ToBackendAddressPoolTunnelInterfaceArrayOutputWithContext 

func (i BackendAddressPoolTunnelInterfaceArray) ToBackendAddressPoolTunnelInterfaceArrayOutputWithContext(ctx context.Context) BackendAddressPoolTunnelInterfaceArrayOutput

type BackendAddressPoolTunnelInterfaceArrayInput 

type BackendAddressPoolTunnelInterfaceArrayInput interface {
	pulumi.Input

	ToBackendAddressPoolTunnelInterfaceArrayOutput() BackendAddressPoolTunnelInterfaceArrayOutput
	ToBackendAddressPoolTunnelInterfaceArrayOutputWithContext(context.Context) BackendAddressPoolTunnelInterfaceArrayOutput
}

BackendAddressPoolTunnelInterfaceArrayInput is an input type that accepts BackendAddressPoolTunnelInterfaceArray and BackendAddressPoolTunnelInterfaceArrayOutput values. You can construct a concrete instance of `BackendAddressPoolTunnelInterfaceArrayInput` via: 

BackendAddressPoolTunnelInterfaceArray{ BackendAddressPoolTunnelInterfaceArgs{...} }

type BackendAddressPoolTunnelInterfaceArrayOutput 

type BackendAddressPoolTunnelInterfaceArrayOutput struct{ *pulumi.OutputState }

func (BackendAddressPoolTunnelInterfaceArrayOutput) ElementType 

func (BackendAddressPoolTunnelInterfaceArrayOutput) ElementType() reflect.Type

func (BackendAddressPoolTunnelInterfaceArrayOutput) Index 

func (o BackendAddressPoolTunnelInterfaceArrayOutput) Index(i pulumi.IntInput) BackendAddressPoolTunnelInterfaceOutput

func (BackendAddressPoolTunnelInterfaceArrayOutput) ToBackendAddressPoolTunnelInterfaceArrayOutput 

func (o BackendAddressPoolTunnelInterfaceArrayOutput) ToBackendAddressPoolTunnelInterfaceArrayOutput() BackendAddressPoolTunnelInterfaceArrayOutput

func (BackendAddressPoolTunnelInterfaceArrayOutput) ToBackendAddressPoolTunnelInterfaceArrayOutputWithContext 

func (o BackendAddressPoolTunnelInterfaceArrayOutput) ToBackendAddressPoolTunnelInterfaceArrayOutputWithContext(ctx context.Context) BackendAddressPoolTunnelInterfaceArrayOutput

type BackendAddressPoolTunnelInterfaceInput 

type BackendAddressPoolTunnelInterfaceInput interface {
	pulumi.Input

	ToBackendAddressPoolTunnelInterfaceOutput() BackendAddressPoolTunnelInterfaceOutput
	ToBackendAddressPoolTunnelInterfaceOutputWithContext(context.Context) BackendAddressPoolTunnelInterfaceOutput
}

BackendAddressPoolTunnelInterfaceInput is an input type that accepts BackendAddressPoolTunnelInterfaceArgs and BackendAddressPoolTunnelInterfaceOutput values. You can construct a concrete instance of `BackendAddressPoolTunnelInterfaceInput` via: 

BackendAddressPoolTunnelInterfaceArgs{...}

type BackendAddressPoolTunnelInterfaceOutput 

type BackendAddressPoolTunnelInterfaceOutput struct{ *pulumi.OutputState }

func (BackendAddressPoolTunnelInterfaceOutput) ElementType 

func (BackendAddressPoolTunnelInterfaceOutput) ElementType() reflect.Type

func (BackendAddressPoolTunnelInterfaceOutput) Identifier 

func (o BackendAddressPoolTunnelInterfaceOutput) Identifier() pulumi.IntOutput

The unique identifier of this Gateway Load Balancer Tunnel Interface.

func (BackendAddressPoolTunnelInterfaceOutput) Port 

func (o BackendAddressPoolTunnelInterfaceOutput) Port() pulumi.IntOutput

The port number that this Gateway Load Balancer Tunnel Interface listens to.

func (BackendAddressPoolTunnelInterfaceOutput) Protocol 

func (o BackendAddressPoolTunnelInterfaceOutput) Protocol() pulumi.StringOutput

The protocol used for this Gateway Load Balancer Tunnel Interface. Possible values are `None`, `Native` and `VXLAN`.

func (BackendAddressPoolTunnelInterfaceOutput) ToBackendAddressPoolTunnelInterfaceOutput 

func (o BackendAddressPoolTunnelInterfaceOutput) ToBackendAddressPoolTunnelInterfaceOutput() BackendAddressPoolTunnelInterfaceOutput

func (BackendAddressPoolTunnelInterfaceOutput) ToBackendAddressPoolTunnelInterfaceOutputWithContext 

func (o BackendAddressPoolTunnelInterfaceOutput) ToBackendAddressPoolTunnelInterfaceOutputWithContext(ctx context.Context) BackendAddressPoolTunnelInterfaceOutput

func (BackendAddressPoolTunnelInterfaceOutput) Type 

func (o BackendAddressPoolTunnelInterfaceOutput) Type() pulumi.StringOutput

The traffic type of this Gateway Load Balancer Tunnel Interface. Possible values are `None`, `Internal` and `External`.

type GetBackendAddressPoolBackendAddress 

type GetBackendAddressPoolBackendAddress struct {
	// A list of `inboundNatRulePortMapping` block as defined below.
	InboundNatRulePortMappings []GetBackendAddressPoolBackendAddressInboundNatRulePortMapping `pulumi:"inboundNatRulePortMappings"`
	// The Static IP address for this Load Balancer within the Virtual Network.
	IpAddress string `pulumi:"ipAddress"`
	// Specifies the name of the Backend Address Pool.
	Name string `pulumi:"name"`
	// The ID of the Virtual Network where the Backend Address of the Load Balancer exists.
	VirtualNetworkId string `pulumi:"virtualNetworkId"`
}

type GetBackendAddressPoolBackendAddressArgs 

type GetBackendAddressPoolBackendAddressArgs struct {
	// A list of `inboundNatRulePortMapping` block as defined below.
	InboundNatRulePortMappings GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayInput `pulumi:"inboundNatRulePortMappings"`
	// The Static IP address for this Load Balancer within the Virtual Network.
	IpAddress pulumi.StringInput `pulumi:"ipAddress"`
	// Specifies the name of the Backend Address Pool.
	Name pulumi.StringInput `pulumi:"name"`
	// The ID of the Virtual Network where the Backend Address of the Load Balancer exists.
	VirtualNetworkId pulumi.StringInput `pulumi:"virtualNetworkId"`
}

func (GetBackendAddressPoolBackendAddressArgs) ElementType 

func (GetBackendAddressPoolBackendAddressArgs) ElementType() reflect.Type

func (GetBackendAddressPoolBackendAddressArgs) ToGetBackendAddressPoolBackendAddressOutput 

func (i GetBackendAddressPoolBackendAddressArgs) ToGetBackendAddressPoolBackendAddressOutput() GetBackendAddressPoolBackendAddressOutput

func (GetBackendAddressPoolBackendAddressArgs) ToGetBackendAddressPoolBackendAddressOutputWithContext 

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

type GetBackendAddressPoolBackendAddressArray 

type GetBackendAddressPoolBackendAddressArray []GetBackendAddressPoolBackendAddressInput

func (GetBackendAddressPoolBackendAddressArray) ElementType 

func (GetBackendAddressPoolBackendAddressArray) ElementType() reflect.Type

func (GetBackendAddressPoolBackendAddressArray) ToGetBackendAddressPoolBackendAddressArrayOutput 

func (i GetBackendAddressPoolBackendAddressArray) ToGetBackendAddressPoolBackendAddressArrayOutput() GetBackendAddressPoolBackendAddressArrayOutput

func (GetBackendAddressPoolBackendAddressArray) ToGetBackendAddressPoolBackendAddressArrayOutputWithContext 

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

type GetBackendAddressPoolBackendAddressArrayInput 

type GetBackendAddressPoolBackendAddressArrayInput interface {
	pulumi.Input

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

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

GetBackendAddressPoolBackendAddressArray{ GetBackendAddressPoolBackendAddressArgs{...} }

type GetBackendAddressPoolBackendAddressArrayOutput 

type GetBackendAddressPoolBackendAddressArrayOutput struct{ *pulumi.OutputState }

func (GetBackendAddressPoolBackendAddressArrayOutput) ElementType 

func (GetBackendAddressPoolBackendAddressArrayOutput) ElementType() reflect.Type

func (GetBackendAddressPoolBackendAddressArrayOutput) Index 

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

func (GetBackendAddressPoolBackendAddressArrayOutput) ToGetBackendAddressPoolBackendAddressArrayOutput 

func (o GetBackendAddressPoolBackendAddressArrayOutput) ToGetBackendAddressPoolBackendAddressArrayOutput() GetBackendAddressPoolBackendAddressArrayOutput

func (GetBackendAddressPoolBackendAddressArrayOutput) ToGetBackendAddressPoolBackendAddressArrayOutputWithContext 

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

type GetBackendAddressPoolBackendAddressInboundNatRulePortMapping added in v5.12.0 

type GetBackendAddressPoolBackendAddressInboundNatRulePortMapping struct {
	// The Backend Port of the Load Balancing Inbound NAT Rules associated with this Backend Address Pool Address.
	BackendPort int `pulumi:"backendPort"`
	// The Frontend Port of the Load Balancing Inbound NAT Rules associated with this Backend Address Pool Address.
	FrontendPort int `pulumi:"frontendPort"`
	// The name of the Load Balancing Inbound NAT Rules associated with this Backend Address Pool Address.
	InboundNatRuleName string `pulumi:"inboundNatRuleName"`
}

type GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArgs added in v5.12.0 

type GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArgs struct {
	// The Backend Port of the Load Balancing Inbound NAT Rules associated with this Backend Address Pool Address.
	BackendPort pulumi.IntInput `pulumi:"backendPort"`
	// The Frontend Port of the Load Balancing Inbound NAT Rules associated with this Backend Address Pool Address.
	FrontendPort pulumi.IntInput `pulumi:"frontendPort"`
	// The name of the Load Balancing Inbound NAT Rules associated with this Backend Address Pool Address.
	InboundNatRuleName pulumi.StringInput `pulumi:"inboundNatRuleName"`
}

func (GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArgs) ElementType added in v5.12.0 

func (GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArgs) ElementType() reflect.Type

func (GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArgs) ToGetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutput added in v5.12.0 

func (i GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArgs) ToGetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutput() GetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutput

func (GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArgs) ToGetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutputWithContext added in v5.12.0 

func (i GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArgs) ToGetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutputWithContext(ctx context.Context) GetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutput

type GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArray added in v5.12.0 

type GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArray []GetBackendAddressPoolBackendAddressInboundNatRulePortMappingInput

func (GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArray) ElementType added in v5.12.0 

func (GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArray) ElementType() reflect.Type

func (GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArray) ToGetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayOutput added in v5.12.0 

func (i GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArray) ToGetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayOutput() GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayOutput

func (GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArray) ToGetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayOutputWithContext added in v5.12.0 

func (i GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArray) ToGetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayOutputWithContext(ctx context.Context) GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayOutput

type GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayInput added in v5.12.0 

type GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayInput interface {
	pulumi.Input

	ToGetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayOutput() GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayOutput
	ToGetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayOutputWithContext(context.Context) GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayOutput
}

GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayInput is an input type that accepts GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArray and GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayOutput values. You can construct a concrete instance of `GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayInput` via: 

GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArray{ GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArgs{...} }

type GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayOutput added in v5.12.0 

type GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayOutput struct{ *pulumi.OutputState }

func (GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayOutput) ElementType added in v5.12.0 

func (GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayOutput) ElementType() reflect.Type

func (GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayOutput) Index added in v5.12.0 

func (o GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayOutput) Index(i pulumi.IntInput) GetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutput

func (GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayOutput) ToGetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayOutput added in v5.12.0 

func (o GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayOutput) ToGetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayOutput() GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayOutput

func (GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayOutput) ToGetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayOutputWithContext added in v5.12.0 

func (o GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayOutput) ToGetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayOutputWithContext(ctx context.Context) GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayOutput

type GetBackendAddressPoolBackendAddressInboundNatRulePortMappingInput added in v5.12.0 

type GetBackendAddressPoolBackendAddressInboundNatRulePortMappingInput interface {
	pulumi.Input

	ToGetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutput() GetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutput
	ToGetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutputWithContext(context.Context) GetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutput
}

GetBackendAddressPoolBackendAddressInboundNatRulePortMappingInput is an input type that accepts GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArgs and GetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutput values. You can construct a concrete instance of `GetBackendAddressPoolBackendAddressInboundNatRulePortMappingInput` via: 

GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArgs{...}

type GetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutput added in v5.12.0 

type GetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutput struct{ *pulumi.OutputState }

func (GetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutput) BackendPort added in v5.12.0 

func (o GetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutput) BackendPort() pulumi.IntOutput

The Backend Port of the Load Balancing Inbound NAT Rules associated with this Backend Address Pool Address.

func (GetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutput) ElementType added in v5.12.0 

func (GetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutput) ElementType() reflect.Type

func (GetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutput) FrontendPort added in v5.12.0 

func (o GetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutput) FrontendPort() pulumi.IntOutput

The Frontend Port of the Load Balancing Inbound NAT Rules associated with this Backend Address Pool Address.

func (GetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutput) InboundNatRuleName added in v5.12.0 

func (o GetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutput) InboundNatRuleName() pulumi.StringOutput

The name of the Load Balancing Inbound NAT Rules associated with this Backend Address Pool Address.

func (GetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutput) ToGetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutput added in v5.12.0 

func (o GetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutput) ToGetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutput() GetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutput

func (GetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutput) ToGetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutputWithContext added in v5.12.0 

func (o GetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutput) ToGetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutputWithContext(ctx context.Context) GetBackendAddressPoolBackendAddressInboundNatRulePortMappingOutput

type GetBackendAddressPoolBackendAddressInput 

type GetBackendAddressPoolBackendAddressInput interface {
	pulumi.Input

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

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

GetBackendAddressPoolBackendAddressArgs{...}

type GetBackendAddressPoolBackendAddressOutput 

type GetBackendAddressPoolBackendAddressOutput struct{ *pulumi.OutputState }

func (GetBackendAddressPoolBackendAddressOutput) ElementType 

func (GetBackendAddressPoolBackendAddressOutput) ElementType() reflect.Type

func (GetBackendAddressPoolBackendAddressOutput) InboundNatRulePortMappings added in v5.12.0 

func (o GetBackendAddressPoolBackendAddressOutput) InboundNatRulePortMappings() GetBackendAddressPoolBackendAddressInboundNatRulePortMappingArrayOutput

A list of `inboundNatRulePortMapping` block as defined below.

func (GetBackendAddressPoolBackendAddressOutput) IpAddress 

func (o GetBackendAddressPoolBackendAddressOutput) IpAddress() pulumi.StringOutput

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

func (GetBackendAddressPoolBackendAddressOutput) Name 

func (o GetBackendAddressPoolBackendAddressOutput) Name() pulumi.StringOutput

Specifies the name of the Backend Address Pool.

func (GetBackendAddressPoolBackendAddressOutput) ToGetBackendAddressPoolBackendAddressOutput 

func (o GetBackendAddressPoolBackendAddressOutput) ToGetBackendAddressPoolBackendAddressOutput() GetBackendAddressPoolBackendAddressOutput

func (GetBackendAddressPoolBackendAddressOutput) ToGetBackendAddressPoolBackendAddressOutputWithContext 

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

func (GetBackendAddressPoolBackendAddressOutput) VirtualNetworkId 

func (o GetBackendAddressPoolBackendAddressOutput) VirtualNetworkId() pulumi.StringOutput

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

type GetBackendAddressPoolBackendIpConfiguration 

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

type GetBackendAddressPoolBackendIpConfigurationArgs 

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

func (GetBackendAddressPoolBackendIpConfigurationArgs) ElementType 

func (GetBackendAddressPoolBackendIpConfigurationArgs) ElementType() reflect.Type

func (GetBackendAddressPoolBackendIpConfigurationArgs) ToGetBackendAddressPoolBackendIpConfigurationOutput 

func (i GetBackendAddressPoolBackendIpConfigurationArgs) ToGetBackendAddressPoolBackendIpConfigurationOutput() GetBackendAddressPoolBackendIpConfigurationOutput

func (GetBackendAddressPoolBackendIpConfigurationArgs) ToGetBackendAddressPoolBackendIpConfigurationOutputWithContext 

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

type GetBackendAddressPoolBackendIpConfigurationArray 

type GetBackendAddressPoolBackendIpConfigurationArray []GetBackendAddressPoolBackendIpConfigurationInput

func (GetBackendAddressPoolBackendIpConfigurationArray) ElementType 

func (GetBackendAddressPoolBackendIpConfigurationArray) ElementType() reflect.Type

func (GetBackendAddressPoolBackendIpConfigurationArray) ToGetBackendAddressPoolBackendIpConfigurationArrayOutput 

func (i GetBackendAddressPoolBackendIpConfigurationArray) ToGetBackendAddressPoolBackendIpConfigurationArrayOutput() GetBackendAddressPoolBackendIpConfigurationArrayOutput

func (GetBackendAddressPoolBackendIpConfigurationArray) ToGetBackendAddressPoolBackendIpConfigurationArrayOutputWithContext 

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

type GetBackendAddressPoolBackendIpConfigurationArrayInput 

type GetBackendAddressPoolBackendIpConfigurationArrayInput interface {
	pulumi.Input

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

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

GetBackendAddressPoolBackendIpConfigurationArray{ GetBackendAddressPoolBackendIpConfigurationArgs{...} }

type GetBackendAddressPoolBackendIpConfigurationArrayOutput 

type GetBackendAddressPoolBackendIpConfigurationArrayOutput struct{ *pulumi.OutputState }

func (GetBackendAddressPoolBackendIpConfigurationArrayOutput) ElementType 

func (GetBackendAddressPoolBackendIpConfigurationArrayOutput) ElementType() reflect.Type

func (GetBackendAddressPoolBackendIpConfigurationArrayOutput) Index 

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

func (GetBackendAddressPoolBackendIpConfigurationArrayOutput) ToGetBackendAddressPoolBackendIpConfigurationArrayOutput 

func (o GetBackendAddressPoolBackendIpConfigurationArrayOutput) ToGetBackendAddressPoolBackendIpConfigurationArrayOutput() GetBackendAddressPoolBackendIpConfigurationArrayOutput

func (GetBackendAddressPoolBackendIpConfigurationArrayOutput) ToGetBackendAddressPoolBackendIpConfigurationArrayOutputWithContext 

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

type GetBackendAddressPoolBackendIpConfigurationInput 

type GetBackendAddressPoolBackendIpConfigurationInput interface {
	pulumi.Input

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

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

GetBackendAddressPoolBackendIpConfigurationArgs{...}

type GetBackendAddressPoolBackendIpConfigurationOutput 

type GetBackendAddressPoolBackendIpConfigurationOutput struct{ *pulumi.OutputState }

func (GetBackendAddressPoolBackendIpConfigurationOutput) ElementType 

func (GetBackendAddressPoolBackendIpConfigurationOutput) ElementType() reflect.Type

func (GetBackendAddressPoolBackendIpConfigurationOutput) Id 

func (o GetBackendAddressPoolBackendIpConfigurationOutput) Id() pulumi.StringOutput

The ID of the Backend Address Pool.

func (GetBackendAddressPoolBackendIpConfigurationOutput) ToGetBackendAddressPoolBackendIpConfigurationOutput 

func (o GetBackendAddressPoolBackendIpConfigurationOutput) ToGetBackendAddressPoolBackendIpConfigurationOutput() GetBackendAddressPoolBackendIpConfigurationOutput

func (GetBackendAddressPoolBackendIpConfigurationOutput) ToGetBackendAddressPoolBackendIpConfigurationOutputWithContext 

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

type GetLBArgs 

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

A collection of arguments for invoking getLB.

type GetLBFrontendIpConfiguration 

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

type GetLBFrontendIpConfigurationArgs 

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

func (GetLBFrontendIpConfigurationArgs) ElementType 

func (GetLBFrontendIpConfigurationArgs) ElementType() reflect.Type

func (GetLBFrontendIpConfigurationArgs) ToGetLBFrontendIpConfigurationOutput 

func (i GetLBFrontendIpConfigurationArgs) ToGetLBFrontendIpConfigurationOutput() GetLBFrontendIpConfigurationOutput

func (GetLBFrontendIpConfigurationArgs) ToGetLBFrontendIpConfigurationOutputWithContext 

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

type GetLBFrontendIpConfigurationArray 

type GetLBFrontendIpConfigurationArray []GetLBFrontendIpConfigurationInput

func (GetLBFrontendIpConfigurationArray) ElementType 

func (GetLBFrontendIpConfigurationArray) ElementType() reflect.Type

func (GetLBFrontendIpConfigurationArray) ToGetLBFrontendIpConfigurationArrayOutput 

func (i GetLBFrontendIpConfigurationArray) ToGetLBFrontendIpConfigurationArrayOutput() GetLBFrontendIpConfigurationArrayOutput

func (GetLBFrontendIpConfigurationArray) ToGetLBFrontendIpConfigurationArrayOutputWithContext 

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

type GetLBFrontendIpConfigurationArrayInput 

type GetLBFrontendIpConfigurationArrayInput interface {
	pulumi.Input

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

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

GetLBFrontendIpConfigurationArray{ GetLBFrontendIpConfigurationArgs{...} }

type GetLBFrontendIpConfigurationArrayOutput 

type GetLBFrontendIpConfigurationArrayOutput struct{ *pulumi.OutputState }

func (GetLBFrontendIpConfigurationArrayOutput) ElementType 

func (GetLBFrontendIpConfigurationArrayOutput) ElementType() reflect.Type

func (GetLBFrontendIpConfigurationArrayOutput) Index 

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

func (GetLBFrontendIpConfigurationArrayOutput) ToGetLBFrontendIpConfigurationArrayOutput 

func (o GetLBFrontendIpConfigurationArrayOutput) ToGetLBFrontendIpConfigurationArrayOutput() GetLBFrontendIpConfigurationArrayOutput

func (GetLBFrontendIpConfigurationArrayOutput) ToGetLBFrontendIpConfigurationArrayOutputWithContext 

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

type GetLBFrontendIpConfigurationInput 

type GetLBFrontendIpConfigurationInput interface {
	pulumi.Input

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

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

GetLBFrontendIpConfigurationArgs{...}

type GetLBFrontendIpConfigurationOutput 

type GetLBFrontendIpConfigurationOutput struct{ *pulumi.OutputState }

func (GetLBFrontendIpConfigurationOutput) ElementType 

func (GetLBFrontendIpConfigurationOutput) ElementType() reflect.Type

func (GetLBFrontendIpConfigurationOutput) Id 

func (o GetLBFrontendIpConfigurationOutput) Id() pulumi.StringOutput

The id of the Frontend IP Configuration.

func (GetLBFrontendIpConfigurationOutput) Name 

func (o GetLBFrontendIpConfigurationOutput) Name() pulumi.StringOutput

Specifies the name of the Load Balancer.

func (GetLBFrontendIpConfigurationOutput) PrivateIpAddress 

func (o GetLBFrontendIpConfigurationOutput) PrivateIpAddress() pulumi.StringOutput

Private IP Address to assign to the Load Balancer.

func (GetLBFrontendIpConfigurationOutput) PrivateIpAddressAllocation 

func (o GetLBFrontendIpConfigurationOutput) PrivateIpAddressAllocation() pulumi.StringOutput

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

func (GetLBFrontendIpConfigurationOutput) PrivateIpAddressVersion 

func (o GetLBFrontendIpConfigurationOutput) PrivateIpAddressVersion() pulumi.StringOutput

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

func (GetLBFrontendIpConfigurationOutput) PublicIpAddressId 

func (o GetLBFrontendIpConfigurationOutput) PublicIpAddressId() pulumi.StringOutput

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

func (GetLBFrontendIpConfigurationOutput) SubnetId 

func (o GetLBFrontendIpConfigurationOutput) SubnetId() pulumi.StringOutput

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

func (GetLBFrontendIpConfigurationOutput) ToGetLBFrontendIpConfigurationOutput 

func (o GetLBFrontendIpConfigurationOutput) ToGetLBFrontendIpConfigurationOutput() GetLBFrontendIpConfigurationOutput

func (GetLBFrontendIpConfigurationOutput) ToGetLBFrontendIpConfigurationOutputWithContext 

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

func (GetLBFrontendIpConfigurationOutput) Zones 

func (o GetLBFrontendIpConfigurationOutput) Zones() pulumi.StringArrayOutput

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

type GetLBOutboundRuleArgs added in v5.28.0 

type GetLBOutboundRuleArgs struct {
	// The ID of the Load Balancer in which the Outbound Rule exists.
	LoadbalancerId string `pulumi:"loadbalancerId"`
	// The name of this Load Balancer Outbound Rule.
	Name string `pulumi:"name"`
}

A collection of arguments for invoking getLBOutboundRule.

type GetLBOutboundRuleFrontendIpConfiguration added in v5.28.0 

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

type GetLBOutboundRuleFrontendIpConfigurationArgs added in v5.28.0 

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

func (GetLBOutboundRuleFrontendIpConfigurationArgs) ElementType added in v5.28.0 

func (GetLBOutboundRuleFrontendIpConfigurationArgs) ElementType() reflect.Type

func (GetLBOutboundRuleFrontendIpConfigurationArgs) ToGetLBOutboundRuleFrontendIpConfigurationOutput added in v5.28.0 

func (i GetLBOutboundRuleFrontendIpConfigurationArgs) ToGetLBOutboundRuleFrontendIpConfigurationOutput() GetLBOutboundRuleFrontendIpConfigurationOutput

func (GetLBOutboundRuleFrontendIpConfigurationArgs) ToGetLBOutboundRuleFrontendIpConfigurationOutputWithContext added in v5.28.0 

func (i GetLBOutboundRuleFrontendIpConfigurationArgs) ToGetLBOutboundRuleFrontendIpConfigurationOutputWithContext(ctx context.Context) GetLBOutboundRuleFrontendIpConfigurationOutput

type GetLBOutboundRuleFrontendIpConfigurationArray added in v5.28.0 

type GetLBOutboundRuleFrontendIpConfigurationArray []GetLBOutboundRuleFrontendIpConfigurationInput

func (GetLBOutboundRuleFrontendIpConfigurationArray) ElementType added in v5.28.0 

func (GetLBOutboundRuleFrontendIpConfigurationArray) ElementType() reflect.Type

func (GetLBOutboundRuleFrontendIpConfigurationArray) ToGetLBOutboundRuleFrontendIpConfigurationArrayOutput added in v5.28.0 

func (i GetLBOutboundRuleFrontendIpConfigurationArray) ToGetLBOutboundRuleFrontendIpConfigurationArrayOutput() GetLBOutboundRuleFrontendIpConfigurationArrayOutput

func (GetLBOutboundRuleFrontendIpConfigurationArray) ToGetLBOutboundRuleFrontendIpConfigurationArrayOutputWithContext added in v5.28.0 

func (i GetLBOutboundRuleFrontendIpConfigurationArray) ToGetLBOutboundRuleFrontendIpConfigurationArrayOutputWithContext(ctx context.Context) GetLBOutboundRuleFrontendIpConfigurationArrayOutput

type GetLBOutboundRuleFrontendIpConfigurationArrayInput added in v5.28.0 

type GetLBOutboundRuleFrontendIpConfigurationArrayInput interface {
	pulumi.Input

	ToGetLBOutboundRuleFrontendIpConfigurationArrayOutput() GetLBOutboundRuleFrontendIpConfigurationArrayOutput
	ToGetLBOutboundRuleFrontendIpConfigurationArrayOutputWithContext(context.Context) GetLBOutboundRuleFrontendIpConfigurationArrayOutput
}

GetLBOutboundRuleFrontendIpConfigurationArrayInput is an input type that accepts GetLBOutboundRuleFrontendIpConfigurationArray and GetLBOutboundRuleFrontendIpConfigurationArrayOutput values. You can construct a concrete instance of `GetLBOutboundRuleFrontendIpConfigurationArrayInput` via: 

GetLBOutboundRuleFrontendIpConfigurationArray{ GetLBOutboundRuleFrontendIpConfigurationArgs{...} }

type GetLBOutboundRuleFrontendIpConfigurationArrayOutput added in v5.28.0 

type GetLBOutboundRuleFrontendIpConfigurationArrayOutput struct{ *pulumi.OutputState }

func (GetLBOutboundRuleFrontendIpConfigurationArrayOutput) ElementType added in v5.28.0 

func (GetLBOutboundRuleFrontendIpConfigurationArrayOutput) ElementType() reflect.Type

func (GetLBOutboundRuleFrontendIpConfigurationArrayOutput) Index added in v5.28.0 

func (o GetLBOutboundRuleFrontendIpConfigurationArrayOutput) Index(i pulumi.IntInput) GetLBOutboundRuleFrontendIpConfigurationOutput

func (GetLBOutboundRuleFrontendIpConfigurationArrayOutput) ToGetLBOutboundRuleFrontendIpConfigurationArrayOutput added in v5.28.0 

func (o GetLBOutboundRuleFrontendIpConfigurationArrayOutput) ToGetLBOutboundRuleFrontendIpConfigurationArrayOutput() GetLBOutboundRuleFrontendIpConfigurationArrayOutput

func (GetLBOutboundRuleFrontendIpConfigurationArrayOutput) ToGetLBOutboundRuleFrontendIpConfigurationArrayOutputWithContext added in v5.28.0 

func (o GetLBOutboundRuleFrontendIpConfigurationArrayOutput) ToGetLBOutboundRuleFrontendIpConfigurationArrayOutputWithContext(ctx context.Context) GetLBOutboundRuleFrontendIpConfigurationArrayOutput

type GetLBOutboundRuleFrontendIpConfigurationInput added in v5.28.0 

type GetLBOutboundRuleFrontendIpConfigurationInput interface {
	pulumi.Input

	ToGetLBOutboundRuleFrontendIpConfigurationOutput() GetLBOutboundRuleFrontendIpConfigurationOutput
	ToGetLBOutboundRuleFrontendIpConfigurationOutputWithContext(context.Context) GetLBOutboundRuleFrontendIpConfigurationOutput
}

GetLBOutboundRuleFrontendIpConfigurationInput is an input type that accepts GetLBOutboundRuleFrontendIpConfigurationArgs and GetLBOutboundRuleFrontendIpConfigurationOutput values. You can construct a concrete instance of `GetLBOutboundRuleFrontendIpConfigurationInput` via: 

GetLBOutboundRuleFrontendIpConfigurationArgs{...}

type GetLBOutboundRuleFrontendIpConfigurationOutput added in v5.28.0 

type GetLBOutboundRuleFrontendIpConfigurationOutput struct{ *pulumi.OutputState }

func (GetLBOutboundRuleFrontendIpConfigurationOutput) ElementType added in v5.28.0 

func (GetLBOutboundRuleFrontendIpConfigurationOutput) ElementType() reflect.Type

func (GetLBOutboundRuleFrontendIpConfigurationOutput) Id added in v5.28.0 

func (o GetLBOutboundRuleFrontendIpConfigurationOutput) Id() pulumi.StringOutput

The ID of the Frontend IP Configuration.

func (GetLBOutboundRuleFrontendIpConfigurationOutput) Name added in v5.28.0 

func (o GetLBOutboundRuleFrontendIpConfigurationOutput) Name() pulumi.StringOutput

The name of this Load Balancer Outbound Rule.

func (GetLBOutboundRuleFrontendIpConfigurationOutput) ToGetLBOutboundRuleFrontendIpConfigurationOutput added in v5.28.0 

func (o GetLBOutboundRuleFrontendIpConfigurationOutput) ToGetLBOutboundRuleFrontendIpConfigurationOutput() GetLBOutboundRuleFrontendIpConfigurationOutput

func (GetLBOutboundRuleFrontendIpConfigurationOutput) ToGetLBOutboundRuleFrontendIpConfigurationOutputWithContext added in v5.28.0 

func (o GetLBOutboundRuleFrontendIpConfigurationOutput) ToGetLBOutboundRuleFrontendIpConfigurationOutputWithContext(ctx context.Context) GetLBOutboundRuleFrontendIpConfigurationOutput

type GetLBOutboundRuleOutputArgs added in v5.28.0 

type GetLBOutboundRuleOutputArgs struct {
	// The ID of the Load Balancer in which the Outbound Rule exists.
	LoadbalancerId pulumi.StringInput `pulumi:"loadbalancerId"`
	// The name of this Load Balancer Outbound Rule.
	Name pulumi.StringInput `pulumi:"name"`
}

A collection of arguments for invoking getLBOutboundRule.

func (GetLBOutboundRuleOutputArgs) ElementType added in v5.28.0 

func (GetLBOutboundRuleOutputArgs) ElementType() reflect.Type

type GetLBOutboundRuleResult added in v5.28.0 

type GetLBOutboundRuleResult struct {
	// The number of outbound ports used for NAT.
	AllocatedOutboundPorts int `pulumi:"allocatedOutboundPorts"`
	// The ID of the Backend Address Pool. Outbound traffic is randomly load balanced across IPs in the backend IPs.
	BackendAddressPoolId string `pulumi:"backendAddressPoolId"`
	// A `frontendIpConfiguration` block as defined below.
	FrontendIpConfigurations []GetLBOutboundRuleFrontendIpConfiguration `pulumi:"frontendIpConfigurations"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// The timeout for the TCP idle connection.
	IdleTimeoutInMinutes int    `pulumi:"idleTimeoutInMinutes"`
	LoadbalancerId       string `pulumi:"loadbalancerId"`
	// The name of the Frontend IP Configuration.
	Name string `pulumi:"name"`
	// The transport protocol for the external endpoint.
	Protocol string `pulumi:"protocol"`
	// Is the bidirectional TCP Reset on TCP flow idle timeout or unexpected connection termination enabled? This value is useful when the protocol is set to TCP.
	TcpResetEnabled bool `pulumi:"tcpResetEnabled"`
}

A collection of values returned by getLBOutboundRule.

func GetLBOutboundRule added in v5.28.0 

func GetLBOutboundRule(ctx *pulumi.Context, args *GetLBOutboundRuleArgs, opts ...pulumi.InvokeOption) (*GetLBOutboundRuleResult, error)

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

## Example Usage

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := lb.GetLBOutboundRule(ctx, &lb.GetLBOutboundRuleArgs{
			Name:           "existing_lb_outbound_rule",
			LoadbalancerId: "existing_load_balancer_id",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("id", example.Id)
		return nil
	})
}

```

type GetLBOutboundRuleResultOutput added in v5.28.0 

type GetLBOutboundRuleResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getLBOutboundRule.

func GetLBOutboundRuleOutput added in v5.28.0 

func GetLBOutboundRuleOutput(ctx *pulumi.Context, args GetLBOutboundRuleOutputArgs, opts ...pulumi.InvokeOption) GetLBOutboundRuleResultOutput

func (GetLBOutboundRuleResultOutput) AllocatedOutboundPorts added in v5.28.0 

func (o GetLBOutboundRuleResultOutput) AllocatedOutboundPorts() pulumi.IntOutput

The number of outbound ports used for NAT.

func (GetLBOutboundRuleResultOutput) BackendAddressPoolId added in v5.28.0 

func (o GetLBOutboundRuleResultOutput) BackendAddressPoolId() pulumi.StringOutput

The ID of the Backend Address Pool. Outbound traffic is randomly load balanced across IPs in the backend IPs.

func (GetLBOutboundRuleResultOutput) ElementType added in v5.28.0 

func (GetLBOutboundRuleResultOutput) ElementType() reflect.Type

func (GetLBOutboundRuleResultOutput) FrontendIpConfigurations added in v5.28.0 

func (o GetLBOutboundRuleResultOutput) FrontendIpConfigurations() GetLBOutboundRuleFrontendIpConfigurationArrayOutput

A `frontendIpConfiguration` block as defined below.

func (GetLBOutboundRuleResultOutput) Id added in v5.28.0 

func (o GetLBOutboundRuleResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (GetLBOutboundRuleResultOutput) IdleTimeoutInMinutes added in v5.28.0 

func (o GetLBOutboundRuleResultOutput) IdleTimeoutInMinutes() pulumi.IntOutput

The timeout for the TCP idle connection.

func (GetLBOutboundRuleResultOutput) LoadbalancerId added in v5.28.0 

func (o GetLBOutboundRuleResultOutput) LoadbalancerId() pulumi.StringOutput

func (GetLBOutboundRuleResultOutput) Name added in v5.28.0 

func (o GetLBOutboundRuleResultOutput) Name() pulumi.StringOutput

The name of the Frontend IP Configuration.

func (GetLBOutboundRuleResultOutput) Protocol added in v5.28.0 

func (o GetLBOutboundRuleResultOutput) Protocol() pulumi.StringOutput

The transport protocol for the external endpoint.

func (GetLBOutboundRuleResultOutput) TcpResetEnabled added in v5.28.0 

func (o GetLBOutboundRuleResultOutput) TcpResetEnabled() pulumi.BoolOutput

Is the bidirectional TCP Reset on TCP flow idle timeout or unexpected connection termination enabled? This value is useful when the protocol is set to TCP.

func (GetLBOutboundRuleResultOutput) ToGetLBOutboundRuleResultOutput added in v5.28.0 

func (o GetLBOutboundRuleResultOutput) ToGetLBOutboundRuleResultOutput() GetLBOutboundRuleResultOutput

func (GetLBOutboundRuleResultOutput) ToGetLBOutboundRuleResultOutputWithContext added in v5.28.0 

func (o GetLBOutboundRuleResultOutput) ToGetLBOutboundRuleResultOutputWithContext(ctx context.Context) GetLBOutboundRuleResultOutput

type GetLBOutputArgs 

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

A collection of arguments for invoking getLB.

func (GetLBOutputArgs) ElementType 

func (GetLBOutputArgs) ElementType() reflect.Type

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/v5/go/azure/lb"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

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

```

type GetLBResultOutput 

type GetLBResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getLB.

func GetLBOutput 

func GetLBOutput(ctx *pulumi.Context, args GetLBOutputArgs, opts ...pulumi.InvokeOption) GetLBResultOutput

func (GetLBResultOutput) ElementType 

func (GetLBResultOutput) ElementType() reflect.Type

func (GetLBResultOutput) FrontendIpConfigurations 

func (o GetLBResultOutput) FrontendIpConfigurations() GetLBFrontendIpConfigurationArrayOutput

A `frontendIpConfiguration` block as documented below.

func (GetLBResultOutput) Id 

func (o GetLBResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (GetLBResultOutput) Location 

func (o GetLBResultOutput) Location() pulumi.StringOutput

The Azure location where the Load Balancer exists.

func (GetLBResultOutput) Name 

func (o GetLBResultOutput) Name() pulumi.StringOutput

The name of the Frontend IP Configuration.

func (GetLBResultOutput) PrivateIpAddress 

func (o GetLBResultOutput) PrivateIpAddress() pulumi.StringOutput

Private IP Address to assign to the Load Balancer.

func (GetLBResultOutput) PrivateIpAddresses 

func (o GetLBResultOutput) PrivateIpAddresses() pulumi.StringArrayOutput

The list of private IP address assigned to the load balancer in `frontendIpConfiguration` blocks, if any.

func (GetLBResultOutput) ResourceGroupName 

func (o GetLBResultOutput) ResourceGroupName() pulumi.StringOutput

func (GetLBResultOutput) Sku 

func (o GetLBResultOutput) Sku() pulumi.StringOutput

The SKU of the Load Balancer.

func (GetLBResultOutput) Tags 

func (o GetLBResultOutput) Tags() pulumi.StringMapOutput

A mapping of tags assigned to the resource.

func (GetLBResultOutput) ToGetLBResultOutput 

func (o GetLBResultOutput) ToGetLBResultOutput() GetLBResultOutput

func (GetLBResultOutput) ToGetLBResultOutputWithContext 

func (o GetLBResultOutput) ToGetLBResultOutputWithContext(ctx context.Context) GetLBResultOutput

type GetLBRuleArgs 

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

A collection of arguments for invoking getLBRule.

type GetLBRuleOutputArgs 

type GetLBRuleOutputArgs struct {
	// The ID of the Load Balancer Rule.
	LoadbalancerId pulumi.StringInput `pulumi:"loadbalancerId"`
	// The name of this Load Balancer Rule.
	Name pulumi.StringInput `pulumi:"name"`
}

A collection of arguments for invoking getLBRule.

func (GetLBRuleOutputArgs) ElementType 

func (GetLBRuleOutputArgs) ElementType() reflect.Type

type GetLBRuleResult 

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

A collection of values returned by getLBRule.

func GetLBRule 

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

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

type GetLBRuleResultOutput 

type GetLBRuleResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getLBRule.

func GetLBRuleOutput 

func GetLBRuleOutput(ctx *pulumi.Context, args GetLBRuleOutputArgs, opts ...pulumi.InvokeOption) GetLBRuleResultOutput

func (GetLBRuleResultOutput) BackendAddressPoolId 

func (o GetLBRuleResultOutput) BackendAddressPoolId() pulumi.StringOutput

A reference to a Backend Address Pool over which this Load Balancing Rule operates.

func (GetLBRuleResultOutput) BackendPort 

func (o GetLBRuleResultOutput) BackendPort() pulumi.IntOutput

The port used for internal connections on the endpoint.

func (GetLBRuleResultOutput) DisableOutboundSnat 

func (o GetLBRuleResultOutput) DisableOutboundSnat() pulumi.BoolOutput

If outbound SNAT is enabled for this Load Balancer Rule.

func (GetLBRuleResultOutput) ElementType 

func (GetLBRuleResultOutput) ElementType() reflect.Type

func (GetLBRuleResultOutput) EnableFloatingIp 

func (o GetLBRuleResultOutput) EnableFloatingIp() pulumi.BoolOutput

If Floating IPs are enabled for this Load Balancer Rule

func (GetLBRuleResultOutput) EnableTcpReset 

func (o GetLBRuleResultOutput) EnableTcpReset() pulumi.BoolOutput

If TCP Reset is enabled for this Load Balancer Rule.

func (GetLBRuleResultOutput) FrontendIpConfigurationName 

func (o GetLBRuleResultOutput) FrontendIpConfigurationName() pulumi.StringOutput

The name of the frontend IP configuration to which the rule is associated.

func (GetLBRuleResultOutput) FrontendPort 

func (o GetLBRuleResultOutput) FrontendPort() pulumi.IntOutput

The port for the external endpoint.

func (GetLBRuleResultOutput) Id 

func (o GetLBRuleResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (GetLBRuleResultOutput) IdleTimeoutInMinutes 

func (o GetLBRuleResultOutput) IdleTimeoutInMinutes() pulumi.IntOutput

Specifies the idle timeout in minutes for TCP connections.

func (GetLBRuleResultOutput) LoadDistribution 

func (o GetLBRuleResultOutput) LoadDistribution() pulumi.StringOutput

Specifies the load balancing distribution type used by the Load Balancer.

func (GetLBRuleResultOutput) LoadbalancerId 

func (o GetLBRuleResultOutput) LoadbalancerId() pulumi.StringOutput

func (GetLBRuleResultOutput) Name 

func (o GetLBRuleResultOutput) Name() pulumi.StringOutput

func (GetLBRuleResultOutput) ProbeId 

func (o GetLBRuleResultOutput) ProbeId() pulumi.StringOutput

A reference to a Probe used by this Load Balancing Rule.

func (GetLBRuleResultOutput) Protocol 

func (o GetLBRuleResultOutput) Protocol() pulumi.StringOutput

The transport protocol for the external endpoint.

func (GetLBRuleResultOutput) ToGetLBRuleResultOutput 

func (o GetLBRuleResultOutput) ToGetLBRuleResultOutput() GetLBRuleResultOutput

func (GetLBRuleResultOutput) ToGetLBRuleResultOutputWithContext 

func (o GetLBRuleResultOutput) ToGetLBRuleResultOutputWithContext(ctx context.Context) GetLBRuleResultOutput

type LoadBalancer 

type LoadBalancer struct {
	pulumi.CustomResourceState

	// Specifies the Edge Zone within the Azure Region where this Load Balancer should exist. Changing this forces a new Load Balancer to be created.
	EdgeZone pulumi.StringPtrOutput `pulumi:"edgeZone"`
	// One or more `frontendIpConfiguration` blocks as documented below.
	FrontendIpConfigurations LoadBalancerFrontendIpConfigurationArrayOutput `pulumi:"frontendIpConfigurations"`
	// Specifies the supported Azure Region where the Load Balancer should be created. Changing this forces a new resource to be created.
	Location pulumi.StringOutput `pulumi:"location"`
	// Specifies the name of the Load Balancer. Changing this forces a new resource to be created.
	Name pulumi.StringOutput `pulumi:"name"`
	// Private IP Address to assign to the Load Balancer.
	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. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringOutput `pulumi:"resourceGroupName"`
	// The SKU of the Azure Load Balancer. Accepted values are `Basic`, `Standard` and `Gateway`. Defaults to `Basic`. Changing this forces a new resource to be created.
	//
	// > **NOTE:** The `Microsoft.Network/AllowGatewayLoadBalancer` feature is required to be registered in order to use the `Gateway` SKU. The feature can only be registered by the Azure service team, please submit an [Azure support ticket](https://azure.microsoft.com/en-us/support/create-ticket/) for that.
	Sku pulumi.StringPtrOutput `pulumi:"sku"`
	// `skuTier` - (Optional) The SKU tier of this Load Balancer. Possible values are `Global` and `Regional`. Defaults to `Regional`. Changing this forces a new resource to be created.
	SkuTier pulumi.StringPtrOutput `pulumi:"skuTier"`
	// 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/v5/go/azure/core"
"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/lb"
"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/network"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

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

```

## Import

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

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

func GetLoadBalancer 

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

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

func NewLoadBalancer 

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

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

func (*LoadBalancer) ElementType 

func (*LoadBalancer) ElementType() reflect.Type

func (*LoadBalancer) ToLoadBalancerOutput 

func (i *LoadBalancer) ToLoadBalancerOutput() LoadBalancerOutput

func (*LoadBalancer) ToLoadBalancerOutputWithContext 

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

type LoadBalancerArgs 

type LoadBalancerArgs struct {
	// Specifies the Edge Zone within the Azure Region where this Load Balancer should exist. Changing this forces a new Load Balancer to be created.
	EdgeZone pulumi.StringPtrInput
	// One or more `frontendIpConfiguration` blocks as documented below.
	FrontendIpConfigurations LoadBalancerFrontendIpConfigurationArrayInput
	// Specifies the supported Azure Region where the Load Balancer should be created. Changing this forces a new resource to be created.
	Location pulumi.StringPtrInput
	// Specifies the name of the Load Balancer. Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// The name of the Resource Group in which to create the Load Balancer. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringInput
	// The SKU of the Azure Load Balancer. Accepted values are `Basic`, `Standard` and `Gateway`. Defaults to `Basic`. Changing this forces a new resource to be created.
	//
	// > **NOTE:** The `Microsoft.Network/AllowGatewayLoadBalancer` feature is required to be registered in order to use the `Gateway` SKU. The feature can only be registered by the Azure service team, please submit an [Azure support ticket](https://azure.microsoft.com/en-us/support/create-ticket/) for that.
	Sku pulumi.StringPtrInput
	// `skuTier` - (Optional) The SKU tier of this Load Balancer. Possible values are `Global` and `Regional`. Defaults to `Regional`. Changing this forces a new resource to be created.
	SkuTier pulumi.StringPtrInput
	// A mapping of tags to assign to the resource.
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a LoadBalancer resource.

func (LoadBalancerArgs) ElementType 

func (LoadBalancerArgs) ElementType() reflect.Type

type LoadBalancerArray 

type LoadBalancerArray []LoadBalancerInput

func (LoadBalancerArray) ElementType 

func (LoadBalancerArray) ElementType() reflect.Type

func (LoadBalancerArray) ToLoadBalancerArrayOutput 

func (i LoadBalancerArray) ToLoadBalancerArrayOutput() LoadBalancerArrayOutput

func (LoadBalancerArray) ToLoadBalancerArrayOutputWithContext 

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

type LoadBalancerArrayInput 

type LoadBalancerArrayInput interface {
	pulumi.Input

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

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

LoadBalancerArray{ LoadBalancerArgs{...} }

type LoadBalancerArrayOutput 

type LoadBalancerArrayOutput struct{ *pulumi.OutputState }

func (LoadBalancerArrayOutput) ElementType 

func (LoadBalancerArrayOutput) ElementType() reflect.Type

func (LoadBalancerArrayOutput) Index 

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

func (LoadBalancerArrayOutput) ToLoadBalancerArrayOutput 

func (o LoadBalancerArrayOutput) ToLoadBalancerArrayOutput() LoadBalancerArrayOutput

func (LoadBalancerArrayOutput) ToLoadBalancerArrayOutputWithContext 

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

type LoadBalancerFrontendIpConfiguration 

type LoadBalancerFrontendIpConfiguration struct {
	// The Frontend IP Configuration ID of a Gateway SKU Load Balancer.
	GatewayLoadBalancerFrontendIpConfigurationId *string `pulumi:"gatewayLoadBalancerFrontendIpConfigurationId"`
	// 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"`
	// Specifies a list of Availability Zones in which the IP Address for this Load Balancer should be located.
	//
	// > **NOTE:** Availability Zones are only supported with a [Standard SKU](https://docs.microsoft.com/azure/load-balancer/load-balancer-standard-availability-zones) and [in select regions](https://docs.microsoft.com/azure/availability-zones/az-overview) at this time.
	Zones []string `pulumi:"zones"`
}

type LoadBalancerFrontendIpConfigurationArgs 

type LoadBalancerFrontendIpConfigurationArgs struct {
	// The Frontend IP Configuration ID of a Gateway SKU Load Balancer.
	GatewayLoadBalancerFrontendIpConfigurationId pulumi.StringPtrInput `pulumi:"gatewayLoadBalancerFrontendIpConfigurationId"`
	// 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"`
	// Specifies a list of Availability Zones in which the IP Address for this Load Balancer should be located.
	//
	// > **NOTE:** Availability Zones are only supported with a [Standard SKU](https://docs.microsoft.com/azure/load-balancer/load-balancer-standard-availability-zones) and [in select regions](https://docs.microsoft.com/azure/availability-zones/az-overview) at this time.
	Zones pulumi.StringArrayInput `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) GatewayLoadBalancerFrontendIpConfigurationId 

func (o LoadBalancerFrontendIpConfigurationOutput) GatewayLoadBalancerFrontendIpConfigurationId() pulumi.StringPtrOutput

The Frontend IP Configuration ID of a Gateway SKU Load Balancer.

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

Specifies a list of Availability Zones in which the IP Address for this Load Balancer should be located.

> **NOTE:** Availability Zones are only supported with a [Standard SKU](https://docs.microsoft.com/azure/load-balancer/load-balancer-standard-availability-zones) and [in select regions](https://docs.microsoft.com/azure/availability-zones/az-overview) at this time.

type LoadBalancerInput 

type LoadBalancerInput interface {
	pulumi.Input

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

type LoadBalancerMap 

type LoadBalancerMap map[string]LoadBalancerInput

func (LoadBalancerMap) ElementType 

func (LoadBalancerMap) ElementType() reflect.Type

func (LoadBalancerMap) ToLoadBalancerMapOutput 

func (i LoadBalancerMap) ToLoadBalancerMapOutput() LoadBalancerMapOutput

func (LoadBalancerMap) ToLoadBalancerMapOutputWithContext 

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

type LoadBalancerMapInput 

type LoadBalancerMapInput interface {
	pulumi.Input

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

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

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

type LoadBalancerMapOutput 

type LoadBalancerMapOutput struct{ *pulumi.OutputState }

func (LoadBalancerMapOutput) ElementType 

func (LoadBalancerMapOutput) ElementType() reflect.Type

func (LoadBalancerMapOutput) MapIndex 

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

func (LoadBalancerMapOutput) ToLoadBalancerMapOutput 

func (o LoadBalancerMapOutput) ToLoadBalancerMapOutput() LoadBalancerMapOutput

func (LoadBalancerMapOutput) ToLoadBalancerMapOutputWithContext 

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

type LoadBalancerOutput 

type LoadBalancerOutput struct{ *pulumi.OutputState }

func (LoadBalancerOutput) EdgeZone added in v5.5.0 

func (o LoadBalancerOutput) EdgeZone() pulumi.StringPtrOutput

Specifies the Edge Zone within the Azure Region where this Load Balancer should exist. Changing this forces a new Load Balancer to be created.

func (LoadBalancerOutput) ElementType 

func (LoadBalancerOutput) ElementType() reflect.Type

func (LoadBalancerOutput) FrontendIpConfigurations added in v5.5.0 

func (o LoadBalancerOutput) FrontendIpConfigurations() LoadBalancerFrontendIpConfigurationArrayOutput

One or more `frontendIpConfiguration` blocks as documented below.

func (LoadBalancerOutput) Location added in v5.5.0 

func (o LoadBalancerOutput) Location() pulumi.StringOutput

Specifies the supported Azure Region where the Load Balancer should be created. Changing this forces a new resource to be created.

func (LoadBalancerOutput) Name added in v5.5.0 

func (o LoadBalancerOutput) Name() pulumi.StringOutput

Specifies the name of the Load Balancer. Changing this forces a new resource to be created.

func (LoadBalancerOutput) PrivateIpAddress added in v5.5.0 

func (o LoadBalancerOutput) PrivateIpAddress() pulumi.StringOutput

Private IP Address to assign to the Load Balancer.

func (LoadBalancerOutput) PrivateIpAddresses added in v5.5.0 

func (o LoadBalancerOutput) PrivateIpAddresses() pulumi.StringArrayOutput

The list of private IP address assigned to the load balancer in `frontendIpConfiguration` blocks, if any.

func (LoadBalancerOutput) ResourceGroupName added in v5.5.0 

func (o LoadBalancerOutput) ResourceGroupName() pulumi.StringOutput

The name of the Resource Group in which to create the Load Balancer. Changing this forces a new resource to be created.

func (LoadBalancerOutput) Sku added in v5.5.0 

func (o LoadBalancerOutput) Sku() pulumi.StringPtrOutput

The SKU of the Azure Load Balancer. Accepted values are `Basic`, `Standard` and `Gateway`. Defaults to `Basic`. Changing this forces a new resource to be created.

> **NOTE:** The `Microsoft.Network/AllowGatewayLoadBalancer` feature is required to be registered in order to use the `Gateway` SKU. The feature can only be registered by the Azure service team, please submit an [Azure support ticket](https://azure.microsoft.com/en-us/support/create-ticket/) for that.

func (LoadBalancerOutput) SkuTier added in v5.5.0 

func (o LoadBalancerOutput) SkuTier() pulumi.StringPtrOutput

`skuTier` - (Optional) The SKU tier of this Load Balancer. Possible values are `Global` and `Regional`. Defaults to `Regional`. Changing this forces a new resource to be created.

func (LoadBalancerOutput) Tags added in v5.5.0 

func (o LoadBalancerOutput) Tags() pulumi.StringMapOutput

A mapping of tags to assign to the resource.

func (LoadBalancerOutput) ToLoadBalancerOutput 

func (o LoadBalancerOutput) ToLoadBalancerOutput() LoadBalancerOutput

func (LoadBalancerOutput) ToLoadBalancerOutputWithContext 

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

type LoadBalancerState 

type LoadBalancerState struct {
	// Specifies the Edge Zone within the Azure Region where this Load Balancer should exist. Changing this forces a new Load Balancer to be created.
	EdgeZone pulumi.StringPtrInput
	// One or more `frontendIpConfiguration` blocks as documented below.
	FrontendIpConfigurations LoadBalancerFrontendIpConfigurationArrayInput
	// Specifies the supported Azure Region where the Load Balancer should be created. Changing this forces a new resource to be created.
	Location pulumi.StringPtrInput
	// Specifies the name of the Load Balancer. Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// Private IP Address to assign to the Load Balancer.
	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. Changing this forces a new resource to be created.
	ResourceGroupName pulumi.StringPtrInput
	// The SKU of the Azure Load Balancer. Accepted values are `Basic`, `Standard` and `Gateway`. Defaults to `Basic`. Changing this forces a new resource to be created.
	//
	// > **NOTE:** The `Microsoft.Network/AllowGatewayLoadBalancer` feature is required to be registered in order to use the `Gateway` SKU. The feature can only be registered by the Azure service team, please submit an [Azure support ticket](https://azure.microsoft.com/en-us/support/create-ticket/) for that.
	Sku pulumi.StringPtrInput
	// `skuTier` - (Optional) The SKU tier of this Load Balancer. Possible values are `Global` and `Regional`. Defaults to `Regional`. Changing this forces a new resource to be created.
	SkuTier 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 LookupBackendAddressPoolOutputArgs 

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

A collection of arguments for invoking getBackendAddressPool.

func (LookupBackendAddressPoolOutputArgs) ElementType 

func (LookupBackendAddressPoolOutputArgs) ElementType() reflect.Type

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 Inbound NAT Rules associated with this Backend Address Pool.
	InboundNatRules []string `pulumi:"inboundNatRules"`
	// 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/v5/go/azure/lb"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

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

```

type LookupBackendAddressPoolResultOutput 

type LookupBackendAddressPoolResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getBackendAddressPool.

func LookupBackendAddressPoolOutput 

func LookupBackendAddressPoolOutput(ctx *pulumi.Context, args LookupBackendAddressPoolOutputArgs, opts ...pulumi.InvokeOption) LookupBackendAddressPoolResultOutput

func (LookupBackendAddressPoolResultOutput) BackendAddresses 

func (o LookupBackendAddressPoolResultOutput) BackendAddresses() GetBackendAddressPoolBackendAddressArrayOutput

A list of `backendAddress` block as defined below.

func (LookupBackendAddressPoolResultOutput) BackendIpConfigurations 

func (o LookupBackendAddressPoolResultOutput) BackendIpConfigurations() GetBackendAddressPoolBackendIpConfigurationArrayOutput

A list of references to IP addresses defined in network interfaces.

func (LookupBackendAddressPoolResultOutput) ElementType 

func (LookupBackendAddressPoolResultOutput) ElementType() reflect.Type

func (LookupBackendAddressPoolResultOutput) Id 

func (o LookupBackendAddressPoolResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (LookupBackendAddressPoolResultOutput) InboundNatRules added in v5.12.0 

func (o LookupBackendAddressPoolResultOutput) InboundNatRules() pulumi.StringArrayOutput

A list of the Load Balancing Inbound NAT Rules associated with this Backend Address Pool.

func (LookupBackendAddressPoolResultOutput) LoadBalancingRules 

func (o LookupBackendAddressPoolResultOutput) LoadBalancingRules() pulumi.StringArrayOutput

A list of the Load Balancing Rules associated with this Backend Address Pool.

func (LookupBackendAddressPoolResultOutput) LoadbalancerId 

func (o LookupBackendAddressPoolResultOutput) LoadbalancerId() pulumi.StringOutput

func (LookupBackendAddressPoolResultOutput) Name 

func (o LookupBackendAddressPoolResultOutput) Name() pulumi.StringOutput

The name of the Backend Address.

func (LookupBackendAddressPoolResultOutput) OutboundRules 

func (o LookupBackendAddressPoolResultOutput) OutboundRules() pulumi.StringArrayOutput

A list of the Load Balancing Outbound Rules associated with this Backend Address Pool.

func (LookupBackendAddressPoolResultOutput) ToLookupBackendAddressPoolResultOutput 

func (o LookupBackendAddressPoolResultOutput) ToLookupBackendAddressPoolResultOutput() LookupBackendAddressPoolResultOutput

func (LookupBackendAddressPoolResultOutput) ToLookupBackendAddressPoolResultOutputWithContext 

func (o LookupBackendAddressPoolResultOutput) ToLookupBackendAddressPoolResultOutputWithContext(ctx context.Context) LookupBackendAddressPoolResultOutput

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"`
	// Are the floating IPs enabled for this Load Balancer Rule? A floating IP is reassigned to a secondary server in case the primary server fails. Required to configure a SQL AlwaysOn Availability Group.
	FloatingIpEnabled         pulumi.BoolPtrOutput `pulumi:"floatingIpEnabled"`
	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"`
	// Specifies the idle timeout in minutes for TCP connections. Valid values are between `4` and `30`. Defaults to `4`.
	IdleTimeoutInMinutes pulumi.IntPtrOutput `pulumi:"idleTimeoutInMinutes"`
	// The ID of the Load Balancer in which to create the NAT pool. Changing this forces a new resource to be created.
	LoadbalancerId pulumi.StringOutput `pulumi:"loadbalancerId"`
	// Specifies the name of the NAT pool. Changing this forces a new resource to be created.
	Name pulumi.StringOutput `pulumi:"name"`
	// The transport protocol for the external endpoint. Possible values are `All`, `Tcp` and `Udp`.
	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"`
	// Is TCP Reset enabled for this Load Balancer Rule?
	TcpResetEnabled pulumi.BoolPtrOutput `pulumi:"tcpResetEnabled"`
}

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

) 

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

```

## Import

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

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

func GetNatPool 

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

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

func NewNatPool 

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

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

func (*NatPool) ElementType 

func (*NatPool) ElementType() reflect.Type

func (*NatPool) ToNatPoolOutput 

func (i *NatPool) ToNatPoolOutput() NatPoolOutput

func (*NatPool) ToNatPoolOutputWithContext 

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

type NatPoolArgs 

type NatPoolArgs struct {
	// The port used for the internal endpoint. Possible values range between 1 and 65535, inclusive.
	BackendPort pulumi.IntInput
	// Are the floating IPs enabled for this Load Balancer Rule? A floating IP is reassigned to a secondary server in case the primary server fails. Required to configure a SQL AlwaysOn Availability Group.
	FloatingIpEnabled pulumi.BoolPtrInput
	// 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
	// Specifies the idle timeout in minutes for TCP connections. Valid values are between `4` and `30`. Defaults to `4`.
	IdleTimeoutInMinutes pulumi.IntPtrInput
	// The ID of the Load Balancer in which to create the NAT pool. Changing this forces a new resource to be created.
	LoadbalancerId pulumi.StringInput
	// Specifies the name of the NAT pool. Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// The transport protocol for the external endpoint. Possible values are `All`, `Tcp` and `Udp`.
	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
	// Is TCP Reset enabled for this Load Balancer Rule?
	TcpResetEnabled pulumi.BoolPtrInput
}

The set of arguments for constructing a NatPool resource.

func (NatPoolArgs) ElementType 

func (NatPoolArgs) ElementType() reflect.Type

type NatPoolArray 

type NatPoolArray []NatPoolInput

func (NatPoolArray) ElementType 

func (NatPoolArray) ElementType() reflect.Type

func (NatPoolArray) ToNatPoolArrayOutput 

func (i NatPoolArray) ToNatPoolArrayOutput() NatPoolArrayOutput

func (NatPoolArray) ToNatPoolArrayOutputWithContext 

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

type NatPoolArrayInput 

type NatPoolArrayInput interface {
	pulumi.Input

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

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

NatPoolArray{ NatPoolArgs{...} }

type NatPoolArrayOutput 

type NatPoolArrayOutput struct{ *pulumi.OutputState }

func (NatPoolArrayOutput) ElementType 

func (NatPoolArrayOutput) ElementType() reflect.Type

func (NatPoolArrayOutput) Index 

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

func (NatPoolArrayOutput) ToNatPoolArrayOutput 

func (o NatPoolArrayOutput) ToNatPoolArrayOutput() NatPoolArrayOutput

func (NatPoolArrayOutput) ToNatPoolArrayOutputWithContext 

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

type NatPoolInput 

type NatPoolInput interface {
	pulumi.Input

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

type NatPoolMap 

type NatPoolMap map[string]NatPoolInput

func (NatPoolMap) ElementType 

func (NatPoolMap) ElementType() reflect.Type

func (NatPoolMap) ToNatPoolMapOutput 

func (i NatPoolMap) ToNatPoolMapOutput() NatPoolMapOutput

func (NatPoolMap) ToNatPoolMapOutputWithContext 

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

type NatPoolMapInput 

type NatPoolMapInput interface {
	pulumi.Input

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

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

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

type NatPoolMapOutput 

type NatPoolMapOutput struct{ *pulumi.OutputState }

func (NatPoolMapOutput) ElementType 

func (NatPoolMapOutput) ElementType() reflect.Type

func (NatPoolMapOutput) MapIndex 

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

func (NatPoolMapOutput) ToNatPoolMapOutput 

func (o NatPoolMapOutput) ToNatPoolMapOutput() NatPoolMapOutput

func (NatPoolMapOutput) ToNatPoolMapOutputWithContext 

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

type NatPoolOutput 

type NatPoolOutput struct{ *pulumi.OutputState }

func (NatPoolOutput) BackendPort added in v5.5.0 

func (o NatPoolOutput) BackendPort() pulumi.IntOutput

The port used for the internal endpoint. Possible values range between 1 and 65535, inclusive.

func (NatPoolOutput) ElementType 

func (NatPoolOutput) ElementType() reflect.Type

func (NatPoolOutput) FloatingIpEnabled added in v5.5.0 

func (o NatPoolOutput) FloatingIpEnabled() pulumi.BoolPtrOutput

Are the floating IPs enabled for this Load Balancer Rule? A floating IP is reassigned to a secondary server in case the primary server fails. Required to configure a SQL AlwaysOn Availability Group.

func (NatPoolOutput) FrontendIpConfigurationId added in v5.5.0 

func (o NatPoolOutput) FrontendIpConfigurationId() pulumi.StringOutput

func (NatPoolOutput) FrontendIpConfigurationName added in v5.5.0 

func (o NatPoolOutput) FrontendIpConfigurationName() pulumi.StringOutput

The name of the frontend IP configuration exposing this rule.

func (NatPoolOutput) FrontendPortEnd added in v5.5.0 

func (o NatPoolOutput) FrontendPortEnd() pulumi.IntOutput

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.

func (NatPoolOutput) FrontendPortStart added in v5.5.0 

func (o NatPoolOutput) FrontendPortStart() pulumi.IntOutput

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.

func (NatPoolOutput) IdleTimeoutInMinutes added in v5.5.0 

func (o NatPoolOutput) IdleTimeoutInMinutes() pulumi.IntPtrOutput

Specifies the idle timeout in minutes for TCP connections. Valid values are between `4` and `30`. Defaults to `4`.

func (NatPoolOutput) LoadbalancerId added in v5.5.0 

func (o NatPoolOutput) LoadbalancerId() pulumi.StringOutput

The ID of the Load Balancer in which to create the NAT pool. Changing this forces a new resource to be created.

func (NatPoolOutput) Name added in v5.5.0 

func (o NatPoolOutput) Name() pulumi.StringOutput

Specifies the name of the NAT pool. Changing this forces a new resource to be created.

func (NatPoolOutput) Protocol added in v5.5.0 

func (o NatPoolOutput) Protocol() pulumi.StringOutput

The transport protocol for the external endpoint. Possible values are `All`, `Tcp` and `Udp`.

func (NatPoolOutput) ResourceGroupName added in v5.5.0 

func (o NatPoolOutput) ResourceGroupName() pulumi.StringOutput

The name of the resource group in which to create the resource. Changing this forces a new resource to be created.

func (NatPoolOutput) TcpResetEnabled added in v5.5.0 

func (o NatPoolOutput) TcpResetEnabled() pulumi.BoolPtrOutput

Is TCP Reset enabled for this Load Balancer Rule?

func (NatPoolOutput) ToNatPoolOutput 

func (o NatPoolOutput) ToNatPoolOutput() NatPoolOutput

func (NatPoolOutput) ToNatPoolOutputWithContext 

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

type NatPoolState 

type NatPoolState struct {
	// The port used for the internal endpoint. Possible values range between 1 and 65535, inclusive.
	BackendPort pulumi.IntPtrInput
	// Are the floating IPs enabled for this Load Balancer Rule? A floating IP is reassigned to a secondary server in case the primary server fails. Required to configure a SQL AlwaysOn Availability Group.
	FloatingIpEnabled         pulumi.BoolPtrInput
	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
	// Specifies the idle timeout in minutes for TCP connections. Valid values are between `4` and `30`. Defaults to `4`.
	IdleTimeoutInMinutes pulumi.IntPtrInput
	// The ID of the Load Balancer in which to create the NAT pool. Changing this forces a new resource to be created.
	LoadbalancerId pulumi.StringPtrInput
	// Specifies the name of the NAT pool. Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// The transport protocol for the external endpoint. Possible values are `All`, `Tcp` and `Udp`.
	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
	// Is TCP Reset enabled for this Load Balancer Rule?
	TcpResetEnabled pulumi.BoolPtrInput
}

func (NatPoolState) ElementType 

func (NatPoolState) ElementType() reflect.Type

type NatRule 

type NatRule struct {
	pulumi.CustomResourceState

	// Specifies a reference to backendAddressPool resource.
	BackendAddressPoolId     pulumi.StringPtrOutput `pulumi:"backendAddressPoolId"`
	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 Balancer 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?
	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.IntPtrOutput `pulumi:"frontendPort"`
	// The port range end for the external endpoint. This property is used together with BackendAddressPool and FrontendPortRangeStart. Individual inbound NAT rule port mappings will be created for each backend address from BackendAddressPool. Acceptable values range from 1 to 65534, inclusive.
	FrontendPortEnd pulumi.IntPtrOutput `pulumi:"frontendPortEnd"`
	// The port range start for the external endpoint. This property is used together with BackendAddressPool and FrontendPortRangeEnd. Individual inbound NAT rule port mappings will be created for each backend address from BackendAddressPool. Acceptable values range from 1 to 65534, inclusive.
	FrontendPortStart pulumi.IntPtrOutput `pulumi:"frontendPortStart"`
	// 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. Changing this forces a new resource to be created.
	LoadbalancerId pulumi.StringOutput `pulumi:"loadbalancerId"`
	// Specifies the name of the NAT 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 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

## Import

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

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

func GetNatRule 

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

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

func NewNatRule 

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

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

func (*NatRule) ElementType 

func (*NatRule) ElementType() reflect.Type

func (*NatRule) ToNatRuleOutput 

func (i *NatRule) ToNatRuleOutput() NatRuleOutput

func (*NatRule) ToNatRuleOutputWithContext 

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

type NatRuleArgs 

type NatRuleArgs struct {
	// Specifies a reference to backendAddressPool resource.
	BackendAddressPoolId pulumi.StringPtrInput
	// 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 Balancer 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?
	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.IntPtrInput
	// The port range end for the external endpoint. This property is used together with BackendAddressPool and FrontendPortRangeStart. Individual inbound NAT rule port mappings will be created for each backend address from BackendAddressPool. Acceptable values range from 1 to 65534, inclusive.
	FrontendPortEnd pulumi.IntPtrInput
	// The port range start for the external endpoint. This property is used together with BackendAddressPool and FrontendPortRangeEnd. Individual inbound NAT rule port mappings will be created for each backend address from BackendAddressPool. Acceptable values range from 1 to 65534, inclusive.
	FrontendPortStart 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. Changing this forces a new resource to be created.
	LoadbalancerId pulumi.StringInput
	// Specifies the name of the NAT 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 NatRule resource.

func (NatRuleArgs) ElementType 

func (NatRuleArgs) ElementType() reflect.Type

type NatRuleArray 

type NatRuleArray []NatRuleInput

func (NatRuleArray) ElementType 

func (NatRuleArray) ElementType() reflect.Type

func (NatRuleArray) ToNatRuleArrayOutput 

func (i NatRuleArray) ToNatRuleArrayOutput() NatRuleArrayOutput

func (NatRuleArray) ToNatRuleArrayOutputWithContext 

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

type NatRuleArrayInput 

type NatRuleArrayInput interface {
	pulumi.Input

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

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

NatRuleArray{ NatRuleArgs{...} }

type NatRuleArrayOutput 

type NatRuleArrayOutput struct{ *pulumi.OutputState }

func (NatRuleArrayOutput) ElementType 

func (NatRuleArrayOutput) ElementType() reflect.Type

func (NatRuleArrayOutput) Index 

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

func (NatRuleArrayOutput) ToNatRuleArrayOutput 

func (o NatRuleArrayOutput) ToNatRuleArrayOutput() NatRuleArrayOutput

func (NatRuleArrayOutput) ToNatRuleArrayOutputWithContext 

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

type NatRuleInput 

type NatRuleInput interface {
	pulumi.Input

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

type NatRuleMap 

type NatRuleMap map[string]NatRuleInput

func (NatRuleMap) ElementType 

func (NatRuleMap) ElementType() reflect.Type

func (NatRuleMap) ToNatRuleMapOutput 

func (i NatRuleMap) ToNatRuleMapOutput() NatRuleMapOutput

func (NatRuleMap) ToNatRuleMapOutputWithContext 

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

type NatRuleMapInput 

type NatRuleMapInput interface {
	pulumi.Input

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

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

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

type NatRuleMapOutput 

type NatRuleMapOutput struct{ *pulumi.OutputState }

func (NatRuleMapOutput) ElementType 

func (NatRuleMapOutput) ElementType() reflect.Type

func (NatRuleMapOutput) MapIndex 

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

func (NatRuleMapOutput) ToNatRuleMapOutput 

func (o NatRuleMapOutput) ToNatRuleMapOutput() NatRuleMapOutput

func (NatRuleMapOutput) ToNatRuleMapOutputWithContext 

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

type NatRuleOutput 

type NatRuleOutput struct{ *pulumi.OutputState }

func (NatRuleOutput) BackendAddressPoolId added in v5.12.0 

func (o NatRuleOutput) BackendAddressPoolId() pulumi.StringPtrOutput

Specifies a reference to backendAddressPool resource.

func (NatRuleOutput) BackendIpConfigurationId added in v5.5.0 

func (o NatRuleOutput) BackendIpConfigurationId() pulumi.StringOutput

func (NatRuleOutput) BackendPort added in v5.5.0 

func (o NatRuleOutput) BackendPort() pulumi.IntOutput

The port used for internal connections on the endpoint. Possible values range between 1 and 65535, inclusive.

func (NatRuleOutput) ElementType 

func (NatRuleOutput) ElementType() reflect.Type

func (NatRuleOutput) EnableFloatingIp added in v5.5.0 

func (o NatRuleOutput) EnableFloatingIp() pulumi.BoolOutput

Are the Floating IPs enabled for this Load Balancer 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`.

func (NatRuleOutput) EnableTcpReset added in v5.5.0 

func (o NatRuleOutput) EnableTcpReset() pulumi.BoolPtrOutput

Is TCP Reset enabled for this Load Balancer Rule?

func (NatRuleOutput) FrontendIpConfigurationId added in v5.5.0 

func (o NatRuleOutput) FrontendIpConfigurationId() pulumi.StringOutput

func (NatRuleOutput) FrontendIpConfigurationName added in v5.5.0 

func (o NatRuleOutput) FrontendIpConfigurationName() pulumi.StringOutput

The name of the frontend IP configuration exposing this rule.

func (NatRuleOutput) FrontendPort added in v5.5.0 

func (o NatRuleOutput) FrontendPort() pulumi.IntPtrOutput

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.

func (NatRuleOutput) FrontendPortEnd added in v5.12.0 

func (o NatRuleOutput) FrontendPortEnd() pulumi.IntPtrOutput

The port range end for the external endpoint. This property is used together with BackendAddressPool and FrontendPortRangeStart. Individual inbound NAT rule port mappings will be created for each backend address from BackendAddressPool. Acceptable values range from 1 to 65534, inclusive.

func (NatRuleOutput) FrontendPortStart added in v5.12.0 

func (o NatRuleOutput) FrontendPortStart() pulumi.IntPtrOutput

The port range start for the external endpoint. This property is used together with BackendAddressPool and FrontendPortRangeEnd. Individual inbound NAT rule port mappings will be created for each backend address from BackendAddressPool. Acceptable values range from 1 to 65534, inclusive.

func (NatRuleOutput) IdleTimeoutInMinutes added in v5.5.0 

func (o NatRuleOutput) IdleTimeoutInMinutes() pulumi.IntOutput

Specifies the idle timeout in minutes for TCP connections. Valid values are between `4` and `30` minutes. Defaults to `4` minutes.

func (NatRuleOutput) LoadbalancerId added in v5.5.0 

func (o NatRuleOutput) LoadbalancerId() pulumi.StringOutput

The ID of the Load Balancer in which to create the NAT Rule. Changing this forces a new resource to be created.

func (NatRuleOutput) Name added in v5.5.0 

func (o NatRuleOutput) Name() pulumi.StringOutput

Specifies the name of the NAT Rule. Changing this forces a new resource to be created.

func (NatRuleOutput) Protocol added in v5.5.0 

func (o NatRuleOutput) Protocol() pulumi.StringOutput

The transport protocol for the external endpoint. Possible values are `Udp`, `Tcp` or `All`.

func (NatRuleOutput) ResourceGroupName added in v5.5.0 

func (o NatRuleOutput) ResourceGroupName() pulumi.StringOutput

The name of the resource group in which to create the resource. Changing this forces a new resource to be created.

func (NatRuleOutput) ToNatRuleOutput 

func (o NatRuleOutput) ToNatRuleOutput() NatRuleOutput

func (NatRuleOutput) ToNatRuleOutputWithContext 

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

type NatRuleState 

type NatRuleState struct {
	// Specifies a reference to backendAddressPool resource.
	BackendAddressPoolId     pulumi.StringPtrInput
	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 Balancer 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?
	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
	// The port range end for the external endpoint. This property is used together with BackendAddressPool and FrontendPortRangeStart. Individual inbound NAT rule port mappings will be created for each backend address from BackendAddressPool. Acceptable values range from 1 to 65534, inclusive.
	FrontendPortEnd pulumi.IntPtrInput
	// The port range start for the external endpoint. This property is used together with BackendAddressPool and FrontendPortRangeEnd. Individual inbound NAT rule port mappings will be created for each backend address from BackendAddressPool. Acceptable values range from 1 to 65534, inclusive.
	FrontendPortStart 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. Changing this forces a new resource to be created.
	LoadbalancerId pulumi.StringPtrInput
	// Specifies the name of the NAT 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 (NatRuleState) ElementType 

func (NatRuleState) ElementType() reflect.Type

type OutboundRule 

type OutboundRule struct {
	pulumi.CustomResourceState

	// The number of outbound ports to be used for NAT. Defaults to `1024`.
	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 Defaults to `4`.
	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"`
}

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

) 

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

```

## Import

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

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

func GetOutboundRule 

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

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

func NewOutboundRule 

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

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

func (*OutboundRule) ElementType 

func (*OutboundRule) ElementType() reflect.Type

func (*OutboundRule) ToOutboundRuleOutput 

func (i *OutboundRule) ToOutboundRuleOutput() OutboundRuleOutput

func (*OutboundRule) ToOutboundRuleOutputWithContext 

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

type OutboundRuleArgs 

type OutboundRuleArgs struct {
	// The number of outbound ports to be used for NAT. Defaults to `1024`.
	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 Defaults to `4`.
	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 set of arguments for constructing a OutboundRule resource.

func (OutboundRuleArgs) ElementType 

func (OutboundRuleArgs) ElementType() reflect.Type

type OutboundRuleArray 

type OutboundRuleArray []OutboundRuleInput

func (OutboundRuleArray) ElementType 

func (OutboundRuleArray) ElementType() reflect.Type

func (OutboundRuleArray) ToOutboundRuleArrayOutput 

func (i OutboundRuleArray) ToOutboundRuleArrayOutput() OutboundRuleArrayOutput

func (OutboundRuleArray) ToOutboundRuleArrayOutputWithContext 

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

type OutboundRuleArrayInput 

type OutboundRuleArrayInput interface {
	pulumi.Input

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

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

OutboundRuleArray{ OutboundRuleArgs{...} }

type OutboundRuleArrayOutput 

type OutboundRuleArrayOutput struct{ *pulumi.OutputState }

func (OutboundRuleArrayOutput) ElementType 

func (OutboundRuleArrayOutput) ElementType() reflect.Type

func (OutboundRuleArrayOutput) Index 

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

func (OutboundRuleArrayOutput) ToOutboundRuleArrayOutput 

func (o OutboundRuleArrayOutput) ToOutboundRuleArrayOutput() OutboundRuleArrayOutput

func (OutboundRuleArrayOutput) ToOutboundRuleArrayOutputWithContext 

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

type OutboundRuleFrontendIpConfiguration 

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

type OutboundRuleFrontendIpConfigurationArgs 

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

func (OutboundRuleFrontendIpConfigurationArgs) ElementType 

func (OutboundRuleFrontendIpConfigurationArgs) ElementType() reflect.Type

func (OutboundRuleFrontendIpConfigurationArgs) ToOutboundRuleFrontendIpConfigurationOutput 

func (i OutboundRuleFrontendIpConfigurationArgs) ToOutboundRuleFrontendIpConfigurationOutput() OutboundRuleFrontendIpConfigurationOutput

func (OutboundRuleFrontendIpConfigurationArgs) ToOutboundRuleFrontendIpConfigurationOutputWithContext 

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

type OutboundRuleFrontendIpConfigurationArray 

type OutboundRuleFrontendIpConfigurationArray []OutboundRuleFrontendIpConfigurationInput

func (OutboundRuleFrontendIpConfigurationArray) ElementType 

func (OutboundRuleFrontendIpConfigurationArray) ElementType() reflect.Type

func (OutboundRuleFrontendIpConfigurationArray) ToOutboundRuleFrontendIpConfigurationArrayOutput 

func (i OutboundRuleFrontendIpConfigurationArray) ToOutboundRuleFrontendIpConfigurationArrayOutput() OutboundRuleFrontendIpConfigurationArrayOutput

func (OutboundRuleFrontendIpConfigurationArray) ToOutboundRuleFrontendIpConfigurationArrayOutputWithContext 

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

type OutboundRuleFrontendIpConfigurationArrayInput 

type OutboundRuleFrontendIpConfigurationArrayInput interface {
	pulumi.Input

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

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

OutboundRuleFrontendIpConfigurationArray{ OutboundRuleFrontendIpConfigurationArgs{...} }

type OutboundRuleFrontendIpConfigurationArrayOutput 

type OutboundRuleFrontendIpConfigurationArrayOutput struct{ *pulumi.OutputState }

func (OutboundRuleFrontendIpConfigurationArrayOutput) ElementType 

func (OutboundRuleFrontendIpConfigurationArrayOutput) ElementType() reflect.Type

func (OutboundRuleFrontendIpConfigurationArrayOutput) Index 

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

func (OutboundRuleFrontendIpConfigurationArrayOutput) ToOutboundRuleFrontendIpConfigurationArrayOutput 

func (o OutboundRuleFrontendIpConfigurationArrayOutput) ToOutboundRuleFrontendIpConfigurationArrayOutput() OutboundRuleFrontendIpConfigurationArrayOutput

func (OutboundRuleFrontendIpConfigurationArrayOutput) ToOutboundRuleFrontendIpConfigurationArrayOutputWithContext 

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

type OutboundRuleFrontendIpConfigurationInput 

type OutboundRuleFrontendIpConfigurationInput interface {
	pulumi.Input

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

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

OutboundRuleFrontendIpConfigurationArgs{...}

type OutboundRuleFrontendIpConfigurationOutput 

type OutboundRuleFrontendIpConfigurationOutput struct{ *pulumi.OutputState }

func (OutboundRuleFrontendIpConfigurationOutput) ElementType 

func (OutboundRuleFrontendIpConfigurationOutput) ElementType() reflect.Type

func (OutboundRuleFrontendIpConfigurationOutput) Id 

func (o OutboundRuleFrontendIpConfigurationOutput) Id() pulumi.StringPtrOutput

The ID of the Load Balancer Outbound Rule.

func (OutboundRuleFrontendIpConfigurationOutput) Name 

func (o OutboundRuleFrontendIpConfigurationOutput) Name() pulumi.StringOutput

The name of the Frontend IP Configuration.

func (OutboundRuleFrontendIpConfigurationOutput) ToOutboundRuleFrontendIpConfigurationOutput 

func (o OutboundRuleFrontendIpConfigurationOutput) ToOutboundRuleFrontendIpConfigurationOutput() OutboundRuleFrontendIpConfigurationOutput

func (OutboundRuleFrontendIpConfigurationOutput) ToOutboundRuleFrontendIpConfigurationOutputWithContext 

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

type OutboundRuleInput 

type OutboundRuleInput interface {
	pulumi.Input

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

type OutboundRuleMap 

type OutboundRuleMap map[string]OutboundRuleInput

func (OutboundRuleMap) ElementType 

func (OutboundRuleMap) ElementType() reflect.Type

func (OutboundRuleMap) ToOutboundRuleMapOutput 

func (i OutboundRuleMap) ToOutboundRuleMapOutput() OutboundRuleMapOutput

func (OutboundRuleMap) ToOutboundRuleMapOutputWithContext 

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

type OutboundRuleMapInput 

type OutboundRuleMapInput interface {
	pulumi.Input

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

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

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

type OutboundRuleMapOutput 

type OutboundRuleMapOutput struct{ *pulumi.OutputState }

func (OutboundRuleMapOutput) ElementType 

func (OutboundRuleMapOutput) ElementType() reflect.Type

func (OutboundRuleMapOutput) MapIndex 

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

func (OutboundRuleMapOutput) ToOutboundRuleMapOutput 

func (o OutboundRuleMapOutput) ToOutboundRuleMapOutput() OutboundRuleMapOutput

func (OutboundRuleMapOutput) ToOutboundRuleMapOutputWithContext 

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

type OutboundRuleOutput 

type OutboundRuleOutput struct{ *pulumi.OutputState }

func (OutboundRuleOutput) AllocatedOutboundPorts added in v5.5.0 

func (o OutboundRuleOutput) AllocatedOutboundPorts() pulumi.IntPtrOutput

The number of outbound ports to be used for NAT. Defaults to `1024`.

func (OutboundRuleOutput) BackendAddressPoolId added in v5.5.0 

func (o OutboundRuleOutput) BackendAddressPoolId() pulumi.StringOutput

The ID of the Backend Address Pool. Outbound traffic is randomly load balanced across IPs in the backend IPs.

func (OutboundRuleOutput) ElementType 

func (OutboundRuleOutput) ElementType() reflect.Type

func (OutboundRuleOutput) EnableTcpReset added in v5.5.0 

func (o OutboundRuleOutput) EnableTcpReset() pulumi.BoolPtrOutput

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.

func (OutboundRuleOutput) FrontendIpConfigurations added in v5.5.0 

func (o OutboundRuleOutput) FrontendIpConfigurations() OutboundRuleFrontendIpConfigurationArrayOutput

One or more `frontendIpConfiguration` blocks as defined below.

func (OutboundRuleOutput) IdleTimeoutInMinutes added in v5.5.0 

func (o OutboundRuleOutput) IdleTimeoutInMinutes() pulumi.IntPtrOutput

The timeout for the TCP idle connection Defaults to `4`.

func (OutboundRuleOutput) LoadbalancerId added in v5.5.0 

func (o OutboundRuleOutput) LoadbalancerId() pulumi.StringOutput

The ID of the Load Balancer in which to create the Outbound Rule. Changing this forces a new resource to be created.

func (OutboundRuleOutput) Name added in v5.5.0 

func (o OutboundRuleOutput) Name() pulumi.StringOutput

Specifies the name of the Outbound Rule. Changing this forces a new resource to be created.

func (OutboundRuleOutput) Protocol added in v5.5.0 

func (o OutboundRuleOutput) Protocol() pulumi.StringOutput

The transport protocol for the external endpoint. Possible values are `Udp`, `Tcp` or `All`.

func (OutboundRuleOutput) ToOutboundRuleOutput 

func (o OutboundRuleOutput) ToOutboundRuleOutput() OutboundRuleOutput

func (OutboundRuleOutput) ToOutboundRuleOutputWithContext 

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

type OutboundRuleState 

type OutboundRuleState struct {
	// The number of outbound ports to be used for NAT. Defaults to `1024`.
	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 Defaults to `4`.
	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
}

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 Probe. Changing this forces a new resource to be created.
	LoadbalancerId pulumi.StringOutput `pulumi:"loadbalancerId"`
	// Specifies the name of the Probe. Changing this forces a new resource to be created.
	Name pulumi.StringOutput `pulumi:"name"`
	// The number of failed probe attempts after which the backend endpoint is removed from rotation. Default to `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"`
	// The number of consecutive successful or failed probes that allow or deny traffic to this endpoint. Possible values range from `1` to `100`. The default value is `1`.
	ProbeThreshold pulumi.IntPtrOutput `pulumi:"probeThreshold"`
	// 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. Defaults to `Tcp`.
	Protocol pulumi.StringPtrOutput `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"`
}

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

) 

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

```

## Import

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

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

func GetProbe 

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

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

func NewProbe 

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

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

func (*Probe) ElementType 

func (*Probe) ElementType() reflect.Type

func (*Probe) ToProbeOutput 

func (i *Probe) ToProbeOutput() ProbeOutput

func (*Probe) ToProbeOutputWithContext 

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

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 Probe. Changing this forces a new resource to be created.
	LoadbalancerId pulumi.StringInput
	// Specifies the name of the Probe. Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// The number of failed probe attempts after which the backend endpoint is removed from rotation. Default to `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
	// The number of consecutive successful or failed probes that allow or deny traffic to this endpoint. Possible values range from `1` to `100`. The default value is `1`.
	ProbeThreshold 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. Defaults to `Tcp`.
	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 set of arguments for constructing a Probe resource.

func (ProbeArgs) ElementType 

func (ProbeArgs) ElementType() reflect.Type

type ProbeArray 

type ProbeArray []ProbeInput

func (ProbeArray) ElementType 

func (ProbeArray) ElementType() reflect.Type

func (ProbeArray) ToProbeArrayOutput 

func (i ProbeArray) ToProbeArrayOutput() ProbeArrayOutput

func (ProbeArray) ToProbeArrayOutputWithContext 

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

type ProbeArrayInput 

type ProbeArrayInput interface {
	pulumi.Input

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

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

ProbeArray{ ProbeArgs{...} }

type ProbeArrayOutput 

type ProbeArrayOutput struct{ *pulumi.OutputState }

func (ProbeArrayOutput) ElementType 

func (ProbeArrayOutput) ElementType() reflect.Type

func (ProbeArrayOutput) Index 

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

func (ProbeArrayOutput) ToProbeArrayOutput 

func (o ProbeArrayOutput) ToProbeArrayOutput() ProbeArrayOutput

func (ProbeArrayOutput) ToProbeArrayOutputWithContext 

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

type ProbeInput 

type ProbeInput interface {
	pulumi.Input

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

type ProbeMap 

type ProbeMap map[string]ProbeInput

func (ProbeMap) ElementType 

func (ProbeMap) ElementType() reflect.Type

func (ProbeMap) ToProbeMapOutput 

func (i ProbeMap) ToProbeMapOutput() ProbeMapOutput

func (ProbeMap) ToProbeMapOutputWithContext 

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

type ProbeMapInput 

type ProbeMapInput interface {
	pulumi.Input

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

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

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

type ProbeMapOutput 

type ProbeMapOutput struct{ *pulumi.OutputState }

func (ProbeMapOutput) ElementType 

func (ProbeMapOutput) ElementType() reflect.Type

func (ProbeMapOutput) MapIndex 

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

func (ProbeMapOutput) ToProbeMapOutput 

func (o ProbeMapOutput) ToProbeMapOutput() ProbeMapOutput

func (ProbeMapOutput) ToProbeMapOutputWithContext 

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

type ProbeOutput 

type ProbeOutput struct{ *pulumi.OutputState }

func (ProbeOutput) ElementType 

func (ProbeOutput) ElementType() reflect.Type

func (ProbeOutput) IntervalInSeconds added in v5.5.0 

func (o ProbeOutput) IntervalInSeconds() pulumi.IntPtrOutput

The interval, in seconds between probes to the backend endpoint for health status. The default value is 15, the minimum value is 5.

func (ProbeOutput) LoadBalancerRules added in v5.5.0 

func (o ProbeOutput) LoadBalancerRules() pulumi.StringArrayOutput

func (ProbeOutput) LoadbalancerId added in v5.5.0 

func (o ProbeOutput) LoadbalancerId() pulumi.StringOutput

The ID of the LoadBalancer in which to create the Probe. Changing this forces a new resource to be created.

func (ProbeOutput) Name added in v5.5.0 

func (o ProbeOutput) Name() pulumi.StringOutput

Specifies the name of the Probe. Changing this forces a new resource to be created.

func (ProbeOutput) NumberOfProbes added in v5.5.0 

func (o ProbeOutput) NumberOfProbes() pulumi.IntPtrOutput

The number of failed probe attempts after which the backend endpoint is removed from rotation. Default to `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.

func (ProbeOutput) Port added in v5.5.0 

func (o ProbeOutput) Port() pulumi.IntOutput

Port on which the Probe queries the backend endpoint. Possible values range from 1 to 65535, inclusive.

func (ProbeOutput) ProbeThreshold added in v5.27.0 

func (o ProbeOutput) ProbeThreshold() pulumi.IntPtrOutput

The number of consecutive successful or failed probes that allow or deny traffic to this endpoint. Possible values range from `1` to `100`. The default value is `1`.

func (ProbeOutput) Protocol added in v5.5.0 

func (o ProbeOutput) Protocol() pulumi.StringPtrOutput

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. Defaults to `Tcp`.

func (ProbeOutput) RequestPath added in v5.5.0 

func (o ProbeOutput) RequestPath() pulumi.StringPtrOutput

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.

func (ProbeOutput) ToProbeOutput 

func (o ProbeOutput) ToProbeOutput() ProbeOutput

func (ProbeOutput) ToProbeOutputWithContext 

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

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 Probe. Changing this forces a new resource to be created.
	LoadbalancerId pulumi.StringPtrInput
	// Specifies the name of the Probe. Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// The number of failed probe attempts after which the backend endpoint is removed from rotation. Default to `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
	// The number of consecutive successful or failed probes that allow or deny traffic to this endpoint. Possible values range from `1` to `100`. The default value is `1`.
	ProbeThreshold 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. Defaults to `Tcp`.
	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
}

func (ProbeState) ElementType 

func (ProbeState) ElementType() reflect.Type

type Rule 

type Rule struct {
	pulumi.CustomResourceState

	// A list of reference to a Backend Address Pool over which this Load Balancing Rule operates.
	//
	// > **NOTE:** In most cases users can only set one Backend Address Pool ID in the `backendAddressPoolIds`. Especially, when the sku of the LB is `Gateway`, users can set up to two IDs in the `backendAddressPoolIds`.
	BackendAddressPoolIds pulumi.StringArrayOutput `pulumi:"backendAddressPoolIds"`
	// The port used for internal connections on the endpoint. Possible values range between 0 and 65535, inclusive. A port of `0` means "Any Port".
	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 Balancer 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?
	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. A port of `0` means "Any Port".
	FrontendPort pulumi.IntOutput `pulumi:"frontendPort"`
	// Specifies the idle timeout in minutes for TCP connections. Valid values are between `4` and `100` 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 in the Azure portal 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. Changing this forces a new resource to be created.
	LoadbalancerId pulumi.StringOutput `pulumi:"loadbalancerId"`
	// Specifies the name of the LB Rule. Changing this forces a new resource to be created.
	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"`
}

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

) 

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

```

## Import

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

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

func GetRule 

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

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

func NewRule 

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

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

func (*Rule) ElementType 

func (*Rule) ElementType() reflect.Type

func (*Rule) ToRuleOutput 

func (i *Rule) ToRuleOutput() RuleOutput

func (*Rule) ToRuleOutputWithContext 

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

type RuleArgs 

type RuleArgs struct {
	// A list of reference to a Backend Address Pool over which this Load Balancing Rule operates.
	//
	// > **NOTE:** In most cases users can only set one Backend Address Pool ID in the `backendAddressPoolIds`. Especially, when the sku of the LB is `Gateway`, users can set up to two IDs in the `backendAddressPoolIds`.
	BackendAddressPoolIds pulumi.StringArrayInput
	// The port used for internal connections on the endpoint. Possible values range between 0 and 65535, inclusive. A port of `0` means "Any Port".
	BackendPort pulumi.IntInput
	// Is snat enabled for this Load Balancer Rule? Default `false`.
	DisableOutboundSnat pulumi.BoolPtrInput
	// Are the Floating IPs enabled for this Load Balancer 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?
	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. A port of `0` means "Any Port".
	FrontendPort pulumi.IntInput
	// Specifies the idle timeout in minutes for TCP connections. Valid values are between `4` and `100` 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 in the Azure portal 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. Changing this forces a new resource to be created.
	LoadbalancerId pulumi.StringInput
	// Specifies the name of the LB Rule. Changing this forces a new resource to be created.
	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 set of arguments for constructing a Rule resource.

func (RuleArgs) ElementType 

func (RuleArgs) ElementType() reflect.Type

type RuleArray 

type RuleArray []RuleInput

func (RuleArray) ElementType 

func (RuleArray) ElementType() reflect.Type

func (RuleArray) ToRuleArrayOutput 

func (i RuleArray) ToRuleArrayOutput() RuleArrayOutput

func (RuleArray) ToRuleArrayOutputWithContext 

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

type RuleArrayInput 

type RuleArrayInput interface {
	pulumi.Input

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

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

RuleArray{ RuleArgs{...} }

type RuleArrayOutput 

type RuleArrayOutput struct{ *pulumi.OutputState }

func (RuleArrayOutput) ElementType 

func (RuleArrayOutput) ElementType() reflect.Type

func (RuleArrayOutput) Index 

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

func (RuleArrayOutput) ToRuleArrayOutput 

func (o RuleArrayOutput) ToRuleArrayOutput() RuleArrayOutput

func (RuleArrayOutput) ToRuleArrayOutputWithContext 

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

type RuleInput 

type RuleInput interface {
	pulumi.Input

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

type RuleMap 

type RuleMap map[string]RuleInput

func (RuleMap) ElementType 

func (RuleMap) ElementType() reflect.Type

func (RuleMap) ToRuleMapOutput 

func (i RuleMap) ToRuleMapOutput() RuleMapOutput

func (RuleMap) ToRuleMapOutputWithContext 

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

type RuleMapInput 

type RuleMapInput interface {
	pulumi.Input

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

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

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

type RuleMapOutput 

type RuleMapOutput struct{ *pulumi.OutputState }

func (RuleMapOutput) ElementType 

func (RuleMapOutput) ElementType() reflect.Type

func (RuleMapOutput) MapIndex 

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

func (RuleMapOutput) ToRuleMapOutput 

func (o RuleMapOutput) ToRuleMapOutput() RuleMapOutput

func (RuleMapOutput) ToRuleMapOutputWithContext 

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

type RuleOutput 

type RuleOutput struct{ *pulumi.OutputState }

func (RuleOutput) BackendAddressPoolIds added in v5.5.0 

func (o RuleOutput) BackendAddressPoolIds() pulumi.StringArrayOutput

A list of reference to a Backend Address Pool over which this Load Balancing Rule operates.

> **NOTE:** In most cases users can only set one Backend Address Pool ID in the `backendAddressPoolIds`. Especially, when the sku of the LB is `Gateway`, users can set up to two IDs in the `backendAddressPoolIds`.

func (RuleOutput) BackendPort added in v5.5.0 

func (o RuleOutput) BackendPort() pulumi.IntOutput

The port used for internal connections on the endpoint. Possible values range between 0 and 65535, inclusive. A port of `0` means "Any Port".

func (RuleOutput) DisableOutboundSnat added in v5.5.0 

func (o RuleOutput) DisableOutboundSnat() pulumi.BoolPtrOutput

Is snat enabled for this Load Balancer Rule? Default `false`.

func (RuleOutput) ElementType 

func (RuleOutput) ElementType() reflect.Type

func (RuleOutput) EnableFloatingIp added in v5.5.0 

func (o RuleOutput) EnableFloatingIp() pulumi.BoolPtrOutput

Are the Floating IPs enabled for this Load Balancer 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`.

func (RuleOutput) EnableTcpReset added in v5.5.0 

func (o RuleOutput) EnableTcpReset() pulumi.BoolPtrOutput

Is TCP Reset enabled for this Load Balancer Rule?

func (RuleOutput) FrontendIpConfigurationId added in v5.5.0 

func (o RuleOutput) FrontendIpConfigurationId() pulumi.StringOutput

func (RuleOutput) FrontendIpConfigurationName added in v5.5.0 

func (o RuleOutput) FrontendIpConfigurationName() pulumi.StringOutput

The name of the frontend IP configuration to which the rule is associated.

func (RuleOutput) FrontendPort added in v5.5.0 

func (o RuleOutput) FrontendPort() pulumi.IntOutput

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. A port of `0` means "Any Port".

func (RuleOutput) IdleTimeoutInMinutes added in v5.5.0 

func (o RuleOutput) IdleTimeoutInMinutes() pulumi.IntOutput

Specifies the idle timeout in minutes for TCP connections. Valid values are between `4` and `100` minutes. Defaults to `4` minutes.

func (RuleOutput) LoadDistribution added in v5.5.0 

func (o RuleOutput) LoadDistribution() pulumi.StringOutput

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 in the Azure portal the options are called `None`, `Client IP` and `Client IP and Protocol` respectively.

func (RuleOutput) LoadbalancerId added in v5.5.0 

func (o RuleOutput) LoadbalancerId() pulumi.StringOutput

The ID of the Load Balancer in which to create the Rule. Changing this forces a new resource to be created.

func (RuleOutput) Name added in v5.5.0 

func (o RuleOutput) Name() pulumi.StringOutput

Specifies the name of the LB Rule. Changing this forces a new resource to be created.

func (RuleOutput) ProbeId added in v5.5.0 

func (o RuleOutput) ProbeId() pulumi.StringOutput

A reference to a Probe used by this Load Balancing Rule.

func (RuleOutput) Protocol added in v5.5.0 

func (o RuleOutput) Protocol() pulumi.StringOutput

The transport protocol for the external endpoint. Possible values are `Tcp`, `Udp` or `All`.

func (RuleOutput) ToRuleOutput 

func (o RuleOutput) ToRuleOutput() RuleOutput

func (RuleOutput) ToRuleOutputWithContext 

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

type RuleState 

type RuleState struct {
	// A list of reference to a Backend Address Pool over which this Load Balancing Rule operates.
	//
	// > **NOTE:** In most cases users can only set one Backend Address Pool ID in the `backendAddressPoolIds`. Especially, when the sku of the LB is `Gateway`, users can set up to two IDs in the `backendAddressPoolIds`.
	BackendAddressPoolIds pulumi.StringArrayInput
	// The port used for internal connections on the endpoint. Possible values range between 0 and 65535, inclusive. A port of `0` means "Any Port".
	BackendPort pulumi.IntPtrInput
	// Is snat enabled for this Load Balancer Rule? Default `false`.
	DisableOutboundSnat pulumi.BoolPtrInput
	// Are the Floating IPs enabled for this Load Balancer 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?
	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. A port of `0` means "Any Port".
	FrontendPort pulumi.IntPtrInput
	// Specifies the idle timeout in minutes for TCP connections. Valid values are between `4` and `100` 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 in the Azure portal 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. Changing this forces a new resource to be created.
	LoadbalancerId pulumi.StringPtrInput
	// Specifies the name of the LB Rule. Changing this forces a new resource to be created.
	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
}

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.