lb

package
v3.9.3 Latest Latest
Warning

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

 Go to latest Published: Jun 17, 2020 License: Apache-2.0 Imports: 4 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"`
	// The Load Balancing Rules associated with this Backend Address Pool.
	LoadBalancingRules pulumi.StringArrayOutput `pulumi:"loadBalancingRules"`
	// The ID of the Load Balancer in which to create the Backend Address Pool.
	LoadbalancerId pulumi.StringOutput `pulumi:"loadbalancerId"`
	// Specifies the name of the Backend Address Pool.
	Name pulumi.StringOutput `pulumi:"name"`
	// The name of the resource group in which to create the resource.
	ResourceGroupName pulumi.StringOutput `pulumi:"resourceGroupName"`
}

Manages a Load Balancer Backend Address Pool.

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

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.

type BackendAddressPoolArgs 

type BackendAddressPoolArgs struct {
	// The ID of the Load Balancer in which to create the Backend Address Pool.
	LoadbalancerId pulumi.StringInput
	// Specifies the name of the Backend Address Pool.
	Name pulumi.StringPtrInput
	// The name of the resource group in which to create the resource.
	ResourceGroupName pulumi.StringInput
}

The set of arguments for constructing a BackendAddressPool resource.

func (BackendAddressPoolArgs) ElementType 

func (BackendAddressPoolArgs) ElementType() reflect.Type

type BackendAddressPoolState 

type BackendAddressPoolState struct {
	// The Backend IP Configurations associated with this Backend Address Pool.
	BackendIpConfigurations pulumi.StringArrayInput
	// The Load Balancing Rules associated with this Backend Address Pool.
	LoadBalancingRules pulumi.StringArrayInput
	// The ID of the Load Balancer in which to create the Backend Address Pool.
	LoadbalancerId pulumi.StringPtrInput
	// Specifies the name of the Backend Address Pool.
	Name pulumi.StringPtrInput
	// The name of the resource group in which to create the resource.
	ResourceGroupName pulumi.StringPtrInput
}

func (BackendAddressPoolState) ElementType 

func (BackendAddressPoolState) ElementType() reflect.Type

type GetBackendAddressPoolBackendIpConfiguration 

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

type GetBackendAddressPoolBackendIpConfigurationArgs 

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

func (GetBackendAddressPoolBackendIpConfigurationArgs) ElementType 

func (GetBackendAddressPoolBackendIpConfigurationArgs) ElementType() reflect.Type

func (GetBackendAddressPoolBackendIpConfigurationArgs) ToGetBackendAddressPoolBackendIpConfigurationOutput 

func (i GetBackendAddressPoolBackendIpConfigurationArgs) ToGetBackendAddressPoolBackendIpConfigurationOutput() GetBackendAddressPoolBackendIpConfigurationOutput

func (GetBackendAddressPoolBackendIpConfigurationArgs) ToGetBackendAddressPoolBackendIpConfigurationOutputWithContext 

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

type GetBackendAddressPoolBackendIpConfigurationArray 

type GetBackendAddressPoolBackendIpConfigurationArray []GetBackendAddressPoolBackendIpConfigurationInput

func (GetBackendAddressPoolBackendIpConfigurationArray) ElementType 

func (GetBackendAddressPoolBackendIpConfigurationArray) ElementType() reflect.Type

func (GetBackendAddressPoolBackendIpConfigurationArray) ToGetBackendAddressPoolBackendIpConfigurationArrayOutput 

func (i GetBackendAddressPoolBackendIpConfigurationArray) ToGetBackendAddressPoolBackendIpConfigurationArrayOutput() GetBackendAddressPoolBackendIpConfigurationArrayOutput

func (GetBackendAddressPoolBackendIpConfigurationArray) ToGetBackendAddressPoolBackendIpConfigurationArrayOutputWithContext 

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

type GetBackendAddressPoolBackendIpConfigurationArrayInput 

type GetBackendAddressPoolBackendIpConfigurationArrayInput interface {
	pulumi.Input

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

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

GetBackendAddressPoolBackendIpConfigurationArray{ GetBackendAddressPoolBackendIpConfigurationArgs{...} }

type GetBackendAddressPoolBackendIpConfigurationArrayOutput 

type GetBackendAddressPoolBackendIpConfigurationArrayOutput struct{ *pulumi.OutputState }

func (GetBackendAddressPoolBackendIpConfigurationArrayOutput) ElementType 

func (GetBackendAddressPoolBackendIpConfigurationArrayOutput) ElementType() reflect.Type

func (GetBackendAddressPoolBackendIpConfigurationArrayOutput) Index 

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

func (GetBackendAddressPoolBackendIpConfigurationArrayOutput) ToGetBackendAddressPoolBackendIpConfigurationArrayOutput 

func (o GetBackendAddressPoolBackendIpConfigurationArrayOutput) ToGetBackendAddressPoolBackendIpConfigurationArrayOutput() GetBackendAddressPoolBackendIpConfigurationArrayOutput

func (GetBackendAddressPoolBackendIpConfigurationArrayOutput) ToGetBackendAddressPoolBackendIpConfigurationArrayOutputWithContext 

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

type GetBackendAddressPoolBackendIpConfigurationInput 

type GetBackendAddressPoolBackendIpConfigurationInput interface {
	pulumi.Input

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

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

GetBackendAddressPoolBackendIpConfigurationArgs{...}

type GetBackendAddressPoolBackendIpConfigurationOutput 

type GetBackendAddressPoolBackendIpConfigurationOutput struct{ *pulumi.OutputState }

func (GetBackendAddressPoolBackendIpConfigurationOutput) ElementType 

func (GetBackendAddressPoolBackendIpConfigurationOutput) ElementType() reflect.Type

func (GetBackendAddressPoolBackendIpConfigurationOutput) Id 

func (o GetBackendAddressPoolBackendIpConfigurationOutput) Id() pulumi.StringOutput

The ID of the Backend Address Pool.

func (GetBackendAddressPoolBackendIpConfigurationOutput) ToGetBackendAddressPoolBackendIpConfigurationOutput 

func (o GetBackendAddressPoolBackendIpConfigurationOutput) ToGetBackendAddressPoolBackendIpConfigurationOutput() GetBackendAddressPoolBackendIpConfigurationOutput

func (GetBackendAddressPoolBackendIpConfigurationOutput) ToGetBackendAddressPoolBackendIpConfigurationOutputWithContext 

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

type GetLBArgs 

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

A collection of arguments for invoking getLB.

type GetLBFrontendIpConfiguration 

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

type GetLBFrontendIpConfigurationArgs 

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

func (GetLBFrontendIpConfigurationArgs) ElementType 

func (GetLBFrontendIpConfigurationArgs) ElementType() reflect.Type

func (GetLBFrontendIpConfigurationArgs) ToGetLBFrontendIpConfigurationOutput 

func (i GetLBFrontendIpConfigurationArgs) ToGetLBFrontendIpConfigurationOutput() GetLBFrontendIpConfigurationOutput

func (GetLBFrontendIpConfigurationArgs) ToGetLBFrontendIpConfigurationOutputWithContext 

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

type GetLBFrontendIpConfigurationArray 

type GetLBFrontendIpConfigurationArray []GetLBFrontendIpConfigurationInput

func (GetLBFrontendIpConfigurationArray) ElementType 

func (GetLBFrontendIpConfigurationArray) ElementType() reflect.Type

func (GetLBFrontendIpConfigurationArray) ToGetLBFrontendIpConfigurationArrayOutput 

func (i GetLBFrontendIpConfigurationArray) ToGetLBFrontendIpConfigurationArrayOutput() GetLBFrontendIpConfigurationArrayOutput

func (GetLBFrontendIpConfigurationArray) ToGetLBFrontendIpConfigurationArrayOutputWithContext 

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

type GetLBFrontendIpConfigurationArrayInput 

type GetLBFrontendIpConfigurationArrayInput interface {
	pulumi.Input

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

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

GetLBFrontendIpConfigurationArray{ GetLBFrontendIpConfigurationArgs{...} }

type GetLBFrontendIpConfigurationArrayOutput 

type GetLBFrontendIpConfigurationArrayOutput struct{ *pulumi.OutputState }

func (GetLBFrontendIpConfigurationArrayOutput) ElementType 

func (GetLBFrontendIpConfigurationArrayOutput) ElementType() reflect.Type

func (GetLBFrontendIpConfigurationArrayOutput) Index 

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

func (GetLBFrontendIpConfigurationArrayOutput) ToGetLBFrontendIpConfigurationArrayOutput 

func (o GetLBFrontendIpConfigurationArrayOutput) ToGetLBFrontendIpConfigurationArrayOutput() GetLBFrontendIpConfigurationArrayOutput

func (GetLBFrontendIpConfigurationArrayOutput) ToGetLBFrontendIpConfigurationArrayOutputWithContext 

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

type GetLBFrontendIpConfigurationInput 

type GetLBFrontendIpConfigurationInput interface {
	pulumi.Input

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

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

GetLBFrontendIpConfigurationArgs{...}

type GetLBFrontendIpConfigurationOutput 

type GetLBFrontendIpConfigurationOutput struct{ *pulumi.OutputState }

func (GetLBFrontendIpConfigurationOutput) ElementType 

func (GetLBFrontendIpConfigurationOutput) ElementType() reflect.Type

func (GetLBFrontendIpConfigurationOutput) Id 

func (o GetLBFrontendIpConfigurationOutput) Id() pulumi.StringOutput

The id of the Frontend IP Configuration.

func (GetLBFrontendIpConfigurationOutput) Name 

func (o GetLBFrontendIpConfigurationOutput) Name() pulumi.StringOutput

Specifies the name of the Load Balancer.

func (GetLBFrontendIpConfigurationOutput) PrivateIpAddress 

func (o GetLBFrontendIpConfigurationOutput) PrivateIpAddress() pulumi.StringOutput

Private IP Address to assign to the Load Balancer.

func (GetLBFrontendIpConfigurationOutput) PrivateIpAddressAllocation 

func (o GetLBFrontendIpConfigurationOutput) PrivateIpAddressAllocation() pulumi.StringOutput

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

func (GetLBFrontendIpConfigurationOutput) PrivateIpAddressVersion 

func (o GetLBFrontendIpConfigurationOutput) PrivateIpAddressVersion() pulumi.StringOutput

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

func (GetLBFrontendIpConfigurationOutput) PublicIpAddressId 

func (o GetLBFrontendIpConfigurationOutput) PublicIpAddressId() pulumi.StringOutput

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

func (GetLBFrontendIpConfigurationOutput) SubnetId 

func (o GetLBFrontendIpConfigurationOutput) SubnetId() pulumi.StringOutput

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

func (GetLBFrontendIpConfigurationOutput) ToGetLBFrontendIpConfigurationOutput 

func (o GetLBFrontendIpConfigurationOutput) ToGetLBFrontendIpConfigurationOutput() GetLBFrontendIpConfigurationOutput

func (GetLBFrontendIpConfigurationOutput) ToGetLBFrontendIpConfigurationOutputWithContext 

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

func (GetLBFrontendIpConfigurationOutput) Zones 

func (o GetLBFrontendIpConfigurationOutput) Zones() pulumi.StringArrayOutput

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

type GetLBResult 

type GetLBResult struct {
	// (Optional) 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/sdk/v2/go/pulumi"

) 

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

```

type LoadBalancer 

type LoadBalancer struct {
	pulumi.CustomResourceState

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

Manages a Load Balancer Resource.

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.

type LoadBalancerArgs 

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

The set of arguments for constructing a LoadBalancer resource.

func (LoadBalancerArgs) ElementType 

func (LoadBalancerArgs) ElementType() reflect.Type

type LoadBalancerFrontendIpConfiguration 

type LoadBalancerFrontendIpConfiguration struct {
	// The id of the Frontend IP Configuration.
	Id *string `pulumi:"id"`
	// The list of IDs of inbound rules that use this frontend IP.
	InboundNatRules []string `pulumi:"inboundNatRules"`
	// The list of IDs of load balancing rules that use this frontend IP.
	LoadBalancerRules []string `pulumi:"loadBalancerRules"`
	// Specifies the name of the frontend ip configuration.
	Name string `pulumi:"name"`
	// The list of IDs outbound rules that use this frontend IP.
	OutboundRules []string `pulumi:"outboundRules"`
	// Private IP Address to assign to the Load Balancer. The last one and first four IPs in any range are reserved and cannot be manually assigned.
	PrivateIpAddress *string `pulumi:"privateIpAddress"`
	// The allocation method for the Private IP Address used by this Load Balancer. Possible values as `Dynamic` and `Static`.
	PrivateIpAddressAllocation *string `pulumi:"privateIpAddressAllocation"`
	// The version of IP that the Private IP Address is. Possible values are `IPv4` or `IPv6`.
	PrivateIpAddressVersion *string `pulumi:"privateIpAddressVersion"`
	// The ID of a Public IP Address which should be associated with the Load Balancer.
	PublicIpAddressId *string `pulumi:"publicIpAddressId"`
	// The ID of a Public IP Prefix which should be associated with the Load Balancer. Public IP Prefix can only be used with outbound rules.
	PublicIpPrefixId *string `pulumi:"publicIpPrefixId"`
	// The ID of the Subnet which should be associated with the IP Configuration.
	SubnetId *string `pulumi:"subnetId"`
	// A list of Availability Zones which the Load Balancer's IP Addresses should be created in.
	Zones *string `pulumi:"zones"`
}

type LoadBalancerFrontendIpConfigurationArgs 

type LoadBalancerFrontendIpConfigurationArgs struct {
	// The id of the Frontend IP Configuration.
	Id pulumi.StringPtrInput `pulumi:"id"`
	// The list of IDs of inbound rules that use this frontend IP.
	InboundNatRules pulumi.StringArrayInput `pulumi:"inboundNatRules"`
	// The list of IDs of load balancing rules that use this frontend IP.
	LoadBalancerRules pulumi.StringArrayInput `pulumi:"loadBalancerRules"`
	// Specifies the name of the frontend ip configuration.
	Name pulumi.StringInput `pulumi:"name"`
	// The list of IDs outbound rules that use this frontend IP.
	OutboundRules pulumi.StringArrayInput `pulumi:"outboundRules"`
	// Private IP Address to assign to the Load Balancer. The last one and first four IPs in any range are reserved and cannot be manually assigned.
	PrivateIpAddress pulumi.StringPtrInput `pulumi:"privateIpAddress"`
	// The allocation method for the Private IP Address used by this Load Balancer. Possible values as `Dynamic` and `Static`.
	PrivateIpAddressAllocation pulumi.StringPtrInput `pulumi:"privateIpAddressAllocation"`
	// The version of IP that the Private IP Address is. Possible values are `IPv4` or `IPv6`.
	PrivateIpAddressVersion pulumi.StringPtrInput `pulumi:"privateIpAddressVersion"`
	// The ID of a Public IP Address which should be associated with the Load Balancer.
	PublicIpAddressId pulumi.StringPtrInput `pulumi:"publicIpAddressId"`
	// The ID of a Public IP Prefix which should be associated with the Load Balancer. Public IP Prefix can only be used with outbound rules.
	PublicIpPrefixId pulumi.StringPtrInput `pulumi:"publicIpPrefixId"`
	// The ID of the Subnet which should be associated with the IP Configuration.
	SubnetId pulumi.StringPtrInput `pulumi:"subnetId"`
	// A list of Availability Zones which the Load Balancer's IP Addresses should be created in.
	Zones pulumi.StringPtrInput `pulumi:"zones"`
}

func (LoadBalancerFrontendIpConfigurationArgs) ElementType 

func (LoadBalancerFrontendIpConfigurationArgs) ElementType() reflect.Type

func (LoadBalancerFrontendIpConfigurationArgs) ToLoadBalancerFrontendIpConfigurationOutput 

func (i LoadBalancerFrontendIpConfigurationArgs) ToLoadBalancerFrontendIpConfigurationOutput() LoadBalancerFrontendIpConfigurationOutput

func (LoadBalancerFrontendIpConfigurationArgs) ToLoadBalancerFrontendIpConfigurationOutputWithContext 

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

type LoadBalancerFrontendIpConfigurationArray 

type LoadBalancerFrontendIpConfigurationArray []LoadBalancerFrontendIpConfigurationInput

func (LoadBalancerFrontendIpConfigurationArray) ElementType 

func (LoadBalancerFrontendIpConfigurationArray) ElementType() reflect.Type

func (LoadBalancerFrontendIpConfigurationArray) ToLoadBalancerFrontendIpConfigurationArrayOutput 

func (i LoadBalancerFrontendIpConfigurationArray) ToLoadBalancerFrontendIpConfigurationArrayOutput() LoadBalancerFrontendIpConfigurationArrayOutput

func (LoadBalancerFrontendIpConfigurationArray) ToLoadBalancerFrontendIpConfigurationArrayOutputWithContext 

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

type LoadBalancerFrontendIpConfigurationArrayInput 

type LoadBalancerFrontendIpConfigurationArrayInput interface {
	pulumi.Input

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

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

LoadBalancerFrontendIpConfigurationArray{ LoadBalancerFrontendIpConfigurationArgs{...} }

type LoadBalancerFrontendIpConfigurationArrayOutput 

type LoadBalancerFrontendIpConfigurationArrayOutput struct{ *pulumi.OutputState }

func (LoadBalancerFrontendIpConfigurationArrayOutput) ElementType 

func (LoadBalancerFrontendIpConfigurationArrayOutput) ElementType() reflect.Type

func (LoadBalancerFrontendIpConfigurationArrayOutput) Index 

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

func (LoadBalancerFrontendIpConfigurationArrayOutput) ToLoadBalancerFrontendIpConfigurationArrayOutput 

func (o LoadBalancerFrontendIpConfigurationArrayOutput) ToLoadBalancerFrontendIpConfigurationArrayOutput() LoadBalancerFrontendIpConfigurationArrayOutput

func (LoadBalancerFrontendIpConfigurationArrayOutput) ToLoadBalancerFrontendIpConfigurationArrayOutputWithContext 

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

type LoadBalancerFrontendIpConfigurationInput 

type LoadBalancerFrontendIpConfigurationInput interface {
	pulumi.Input

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

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

LoadBalancerFrontendIpConfigurationArgs{...}

type LoadBalancerFrontendIpConfigurationOutput 

type LoadBalancerFrontendIpConfigurationOutput struct{ *pulumi.OutputState }

func (LoadBalancerFrontendIpConfigurationOutput) ElementType 

func (LoadBalancerFrontendIpConfigurationOutput) ElementType() reflect.Type

func (LoadBalancerFrontendIpConfigurationOutput) Id 

func (o LoadBalancerFrontendIpConfigurationOutput) Id() pulumi.StringPtrOutput

The id of the Frontend IP Configuration.

func (LoadBalancerFrontendIpConfigurationOutput) InboundNatRules 

func (o LoadBalancerFrontendIpConfigurationOutput) InboundNatRules() pulumi.StringArrayOutput

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

func (LoadBalancerFrontendIpConfigurationOutput) LoadBalancerRules 

func (o LoadBalancerFrontendIpConfigurationOutput) LoadBalancerRules() pulumi.StringArrayOutput

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

func (LoadBalancerFrontendIpConfigurationOutput) Name 

func (o LoadBalancerFrontendIpConfigurationOutput) Name() pulumi.StringOutput

Specifies the name of the frontend ip configuration.

func (LoadBalancerFrontendIpConfigurationOutput) OutboundRules 

func (o LoadBalancerFrontendIpConfigurationOutput) OutboundRules() pulumi.StringArrayOutput

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

func (LoadBalancerFrontendIpConfigurationOutput) PrivateIpAddress 

func (o LoadBalancerFrontendIpConfigurationOutput) PrivateIpAddress() pulumi.StringPtrOutput

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

func (LoadBalancerFrontendIpConfigurationOutput) PrivateIpAddressAllocation 

func (o LoadBalancerFrontendIpConfigurationOutput) PrivateIpAddressAllocation() pulumi.StringPtrOutput

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

func (LoadBalancerFrontendIpConfigurationOutput) PrivateIpAddressVersion 

func (o LoadBalancerFrontendIpConfigurationOutput) PrivateIpAddressVersion() pulumi.StringPtrOutput

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

func (LoadBalancerFrontendIpConfigurationOutput) PublicIpAddressId 

func (o LoadBalancerFrontendIpConfigurationOutput) PublicIpAddressId() pulumi.StringPtrOutput

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

func (LoadBalancerFrontendIpConfigurationOutput) PublicIpPrefixId 

func (o LoadBalancerFrontendIpConfigurationOutput) PublicIpPrefixId() pulumi.StringPtrOutput

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

func (LoadBalancerFrontendIpConfigurationOutput) SubnetId 

func (o LoadBalancerFrontendIpConfigurationOutput) SubnetId() pulumi.StringPtrOutput

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

func (LoadBalancerFrontendIpConfigurationOutput) ToLoadBalancerFrontendIpConfigurationOutput 

func (o LoadBalancerFrontendIpConfigurationOutput) ToLoadBalancerFrontendIpConfigurationOutput() LoadBalancerFrontendIpConfigurationOutput

func (LoadBalancerFrontendIpConfigurationOutput) ToLoadBalancerFrontendIpConfigurationOutputWithContext 

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

func (LoadBalancerFrontendIpConfigurationOutput) Zones 

func (o LoadBalancerFrontendIpConfigurationOutput) Zones() pulumi.StringPtrOutput

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

type LoadBalancerState 

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

func (LoadBalancerState) ElementType 

func (LoadBalancerState) ElementType() reflect.Type

type LookupBackendAddressPoolArgs 

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

A collection of arguments for invoking getBackendAddressPool.

type LookupBackendAddressPoolResult 

type LookupBackendAddressPoolResult struct {
	// An array 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"`
	LoadbalancerId string `pulumi:"loadbalancerId"`
	// The name of the Backend Address Pool.
	Name string `pulumi:"name"`
}

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/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleLB, err := lb.LookupLB(ctx, &lb.LookupLBArgs{
			Name:              "example-lb",
			ResourceGroupName: "example-resources",
		}, nil)
		if err != nil {
			return err
		}
		exampleBackendAddressPool, err := lb.LookupBackendAddressPool(ctx, &lb.LookupBackendAddressPoolArgs{
			Name:           "first",
			LoadbalancerId: exampleLB.Id,
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("backendAddressPoolId", exampleBackendAddressPool.Id)
		ctx.Export("backendIpConfigurationIds")
		return nil
	})
}

```

type NatPool 

type NatPool struct {
	pulumi.CustomResourceState

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

Manages a Load Balancer NAT pool.

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

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

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.

type NatPoolArgs 

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

The set of arguments for constructing a NatPool resource.

func (NatPoolArgs) ElementType 

func (NatPoolArgs) ElementType() reflect.Type

type NatPoolState 

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

func (NatPoolState) ElementType 

func (NatPoolState) ElementType() reflect.Type

type NatRule 

type NatRule struct {
	pulumi.CustomResourceState

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

Manages a Load Balancer NAT Rule.

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

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

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.

type NatRuleArgs 

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

The set of arguments for constructing a NatRule resource.

func (NatRuleArgs) ElementType 

func (NatRuleArgs) ElementType() reflect.Type

type NatRuleState 

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

func (NatRuleState) ElementType 

func (NatRuleState) ElementType() reflect.Type

type OutboundRule 

type OutboundRule struct {
	pulumi.CustomResourceState

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

Manages a Load Balancer Outbound Rule.

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

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.

type OutboundRuleArgs 

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

The set of arguments for constructing a OutboundRule resource.

func (OutboundRuleArgs) ElementType 

func (OutboundRuleArgs) ElementType() reflect.Type

type 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 OutboundRuleState 

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

func (OutboundRuleState) ElementType 

func (OutboundRuleState) ElementType() reflect.Type

type Probe 

type Probe struct {
	pulumi.CustomResourceState

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

Manages a LoadBalancer Probe Resource.

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

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.

type ProbeArgs 

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

The set of arguments for constructing a Probe resource.

func (ProbeArgs) ElementType 

func (ProbeArgs) ElementType() reflect.Type

type ProbeState 

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

func (ProbeState) ElementType 

func (ProbeState) ElementType() reflect.Type

type Rule 

type Rule struct {
	pulumi.CustomResourceState

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

Manages a Load Balancer Rule.

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

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.

type RuleArgs 

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

The set of arguments for constructing a Rule resource.

func (RuleArgs) ElementType 

func (RuleArgs) ElementType() reflect.Type

type RuleState 

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

func (RuleState) ElementType 

func (RuleState) ElementType() reflect.Type

Source Files

View all Source files

Jump to

Keyboard shortcuts

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