lb

package
v0.16.5 Latest Latest
Warning

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

 Go to latest Published: Dec 5, 2018 License: Apache-2.0 Imports: 2 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 {
	// contains filtered or unexported fields
}

Manage 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.ID, state *BackendAddressPoolState, opts ...pulumi.ResourceOpt) (*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.ResourceOpt) (*BackendAddressPool, error)

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

func (*BackendAddressPool) BackendIpConfigurations 

func (r *BackendAddressPool) BackendIpConfigurations() *pulumi.ArrayOutput

func (*BackendAddressPool) ID 

func (r *BackendAddressPool) ID() *pulumi.IDOutput

ID is this resource's unique identifier assigned by its provider.

func (*BackendAddressPool) LoadBalancingRules 

func (r *BackendAddressPool) LoadBalancingRules() *pulumi.ArrayOutput

func (*BackendAddressPool) LoadbalancerId 

func (r *BackendAddressPool) LoadbalancerId() *pulumi.StringOutput

The ID of the Load Balancer in which to create the Backend Address Pool.

func (*BackendAddressPool) Location 

func (r *BackendAddressPool) Location() *pulumi.StringOutput

func (*BackendAddressPool) Name 

func (r *BackendAddressPool) Name() *pulumi.StringOutput

Specifies the name of the Backend Address Pool.

func (*BackendAddressPool) ResourceGroupName 

func (r *BackendAddressPool) ResourceGroupName() *pulumi.StringOutput

The name of the resource group in which to create the resource.

func (*BackendAddressPool) URN 

func (r *BackendAddressPool) URN() *pulumi.URNOutput

URN is this resource's unique name assigned by Pulumi.

type BackendAddressPoolArgs 

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

The set of arguments for constructing a BackendAddressPool resource.

type BackendAddressPoolState 

type BackendAddressPoolState struct {
	BackendIpConfigurations interface{}
	LoadBalancingRules      interface{}
	// The ID of the Load Balancer in which to create the Backend Address Pool.
	LoadbalancerId interface{}
	Location       interface{}
	// Specifies the name of the Backend Address Pool.
	Name interface{}
	// The name of the resource group in which to create the resource.
	ResourceGroupName interface{}
}

Input properties used for looking up and filtering BackendAddressPool resources.

type LoadBalancer 

type LoadBalancer struct {
	// contains filtered or unexported fields
}

Manage a Load Balancer Resource.

func GetLoadBalancer 

func GetLoadBalancer(ctx *pulumi.Context,
	name string, id pulumi.ID, state *LoadBalancerState, opts ...pulumi.ResourceOpt) (*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.ResourceOpt) (*LoadBalancer, error)

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

func (*LoadBalancer) FrontendIpConfigurations 

func (r *LoadBalancer) FrontendIpConfigurations() *pulumi.ArrayOutput

A frontend ip configuration block as documented below.

func (*LoadBalancer) ID 

func (r *LoadBalancer) ID() *pulumi.IDOutput

ID is this resource's unique identifier assigned by its provider.

func (*LoadBalancer) Location 

func (r *LoadBalancer) Location() *pulumi.StringOutput

Specifies the supported Azure location where the resource exists.

func (*LoadBalancer) Name 

func (r *LoadBalancer) Name() *pulumi.StringOutput

Specifies the name of the frontend ip configuration.

func (*LoadBalancer) PrivateIpAddress 

func (r *LoadBalancer) PrivateIpAddress() *pulumi.StringOutput

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 (*LoadBalancer) PrivateIpAddresses 

func (r *LoadBalancer) PrivateIpAddresses() *pulumi.ArrayOutput

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

func (*LoadBalancer) ResourceGroupName 

func (r *LoadBalancer) ResourceGroupName() *pulumi.StringOutput

The name of the resource group in which to create the LoadBalancer.

func (*LoadBalancer) Sku 

func (r *LoadBalancer) Sku() *pulumi.StringOutput

The SKU of the Azure Load Balancer. Accepted values are `Basic` and `Standard`. Defaults to `Basic`.

func (*LoadBalancer) Tags 

func (r *LoadBalancer) Tags() *pulumi.MapOutput

A mapping of tags to assign to the resource.

func (*LoadBalancer) URN 

func (r *LoadBalancer) URN() *pulumi.URNOutput

URN is this resource's unique name assigned by Pulumi.

type LoadBalancerArgs 

type LoadBalancerArgs struct {
	// A frontend ip configuration block as documented below.
	FrontendIpConfigurations interface{}
	// Specifies the supported Azure location where the resource exists.
	Location interface{}
	// Specifies the name of the frontend ip configuration.
	Name interface{}
	// The name of the resource group in which to create the LoadBalancer.
	ResourceGroupName interface{}
	// The SKU of the Azure Load Balancer. Accepted values are `Basic` and `Standard`. Defaults to `Basic`.
	Sku interface{}
	// A mapping of tags to assign to the resource.
	Tags interface{}
}

The set of arguments for constructing a LoadBalancer resource.

type LoadBalancerState 

type LoadBalancerState struct {
	// A frontend ip configuration block as documented below.
	FrontendIpConfigurations interface{}
	// Specifies the supported Azure location where the resource exists.
	Location interface{}
	// Specifies the name of the frontend ip configuration.
	Name interface{}
	// 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 interface{}
	// The list of private IP address assigned to the load balancer in `frontend_ip_configuration` blocks, if any.
	PrivateIpAddresses interface{}
	// The name of the resource group in which to create the LoadBalancer.
	ResourceGroupName interface{}
	// The SKU of the Azure Load Balancer. Accepted values are `Basic` and `Standard`. Defaults to `Basic`.
	Sku interface{}
	// A mapping of tags to assign to the resource.
	Tags interface{}
}

Input properties used for looking up and filtering LoadBalancer resources.

type NatPool 

type NatPool struct {
	// contains filtered or unexported fields
}

Manages a Load Balancer NAT pool.

~> **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.ID, state *NatPoolState, opts ...pulumi.ResourceOpt) (*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.ResourceOpt) (*NatPool, error)

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

func (*NatPool) BackendPort 

func (r *NatPool) BackendPort() *pulumi.IntOutput

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

func (*NatPool) FrontendIpConfigurationId 

func (r *NatPool) FrontendIpConfigurationId() *pulumi.StringOutput

func (*NatPool) FrontendIpConfigurationName 

func (r *NatPool) FrontendIpConfigurationName() *pulumi.StringOutput

The name of the frontend IP configuration exposing this rule.

func (*NatPool) FrontendPortEnd 

func (r *NatPool) 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 (*NatPool) FrontendPortStart 

func (r *NatPool) 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 (*NatPool) ID 

func (r *NatPool) ID() *pulumi.IDOutput

ID is this resource's unique identifier assigned by its provider.

func (*NatPool) LoadbalancerId 

func (r *NatPool) LoadbalancerId() *pulumi.StringOutput

The ID of the Load Balancer in which to create the NAT pool.

func (*NatPool) Location 

func (r *NatPool) Location() *pulumi.StringOutput

func (*NatPool) Name 

func (r *NatPool) Name() *pulumi.StringOutput

Specifies the name of the NAT pool.

func (*NatPool) Protocol 

func (r *NatPool) Protocol() *pulumi.StringOutput

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

func (*NatPool) ResourceGroupName 

func (r *NatPool) ResourceGroupName() *pulumi.StringOutput

The name of the resource group in which to create the resource.

func (*NatPool) URN 

func (r *NatPool) URN() *pulumi.URNOutput

URN is this resource's unique name assigned by Pulumi.

type NatPoolArgs 

type NatPoolArgs struct {
	// The port used for the internal endpoint. Possible values range between 1 and 65535, inclusive.
	BackendPort interface{}
	// The name of the frontend IP configuration exposing this rule.
	FrontendIpConfigurationName interface{}
	// 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 interface{}
	// 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 interface{}
	// The ID of the Load Balancer in which to create the NAT pool.
	LoadbalancerId interface{}
	Location       interface{}
	// Specifies the name of the NAT pool.
	Name interface{}
	// The transport protocol for the external endpoint. Possible values are `Udp` or `Tcp`.
	Protocol interface{}
	// The name of the resource group in which to create the resource.
	ResourceGroupName interface{}
}

The set of arguments for constructing a NatPool resource.

type NatPoolState 

type NatPoolState struct {
	// The port used for the internal endpoint. Possible values range between 1 and 65535, inclusive.
	BackendPort               interface{}
	FrontendIpConfigurationId interface{}
	// The name of the frontend IP configuration exposing this rule.
	FrontendIpConfigurationName interface{}
	// 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 interface{}
	// 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 interface{}
	// The ID of the Load Balancer in which to create the NAT pool.
	LoadbalancerId interface{}
	Location       interface{}
	// Specifies the name of the NAT pool.
	Name interface{}
	// The transport protocol for the external endpoint. Possible values are `Udp` or `Tcp`.
	Protocol interface{}
	// The name of the resource group in which to create the resource.
	ResourceGroupName interface{}
}

Input properties used for looking up and filtering NatPool resources.

type NatRule 

type NatRule struct {
	// contains filtered or unexported fields
}

Manages a Load Balancer NAT Rule.

~> **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.ID, state *NatRuleState, opts ...pulumi.ResourceOpt) (*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.ResourceOpt) (*NatRule, error)

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

func (*NatRule) BackendIpConfigurationId 

func (r *NatRule) BackendIpConfigurationId() *pulumi.StringOutput

func (*NatRule) BackendPort 

func (r *NatRule) BackendPort() *pulumi.IntOutput

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

func (*NatRule) EnableFloatingIp 

func (r *NatRule) EnableFloatingIp() *pulumi.BoolOutput

Enables the Floating IP Capacity, required to configure a SQL AlwaysOn Availability Group.

func (*NatRule) FrontendIpConfigurationId 

func (r *NatRule) FrontendIpConfigurationId() *pulumi.StringOutput

func (*NatRule) FrontendIpConfigurationName 

func (r *NatRule) FrontendIpConfigurationName() *pulumi.StringOutput

The name of the frontend IP configuration exposing this rule.

func (*NatRule) FrontendPort 

func (r *NatRule) 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 1 and 65534, inclusive.

func (*NatRule) ID 

func (r *NatRule) ID() *pulumi.IDOutput

ID is this resource's unique identifier assigned by its provider.

func (*NatRule) LoadbalancerId 

func (r *NatRule) LoadbalancerId() *pulumi.StringOutput

The ID of the Load Balancer in which to create the NAT Rule.

func (*NatRule) Location 

func (r *NatRule) Location() *pulumi.StringOutput

func (*NatRule) Name 

func (r *NatRule) Name() *pulumi.StringOutput

Specifies the name of the NAT Rule.

func (*NatRule) Protocol 

func (r *NatRule) Protocol() *pulumi.StringOutput

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

func (*NatRule) ResourceGroupName 

func (r *NatRule) ResourceGroupName() *pulumi.StringOutput

The name of the resource group in which to create the resource.

func (*NatRule) URN 

func (r *NatRule) URN() *pulumi.URNOutput

URN is this resource's unique name assigned by Pulumi.

type NatRuleArgs 

type NatRuleArgs struct {
	// The port used for internal connections on the endpoint. Possible values range between 1 and 65535, inclusive.
	BackendPort interface{}
	// Enables the Floating IP Capacity, required to configure a SQL AlwaysOn Availability Group.
	EnableFloatingIp interface{}
	// The name of the frontend IP configuration exposing this rule.
	FrontendIpConfigurationName interface{}
	// 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 interface{}
	// The ID of the Load Balancer in which to create the NAT Rule.
	LoadbalancerId interface{}
	Location       interface{}
	// Specifies the name of the NAT Rule.
	Name interface{}
	// The transport protocol for the external endpoint. Possible values are `Udp`, `Tcp` or `All`.
	Protocol interface{}
	// The name of the resource group in which to create the resource.
	ResourceGroupName interface{}
}

The set of arguments for constructing a NatRule resource.

type NatRuleState 

type NatRuleState struct {
	BackendIpConfigurationId interface{}
	// The port used for internal connections on the endpoint. Possible values range between 1 and 65535, inclusive.
	BackendPort interface{}
	// Enables the Floating IP Capacity, required to configure a SQL AlwaysOn Availability Group.
	EnableFloatingIp          interface{}
	FrontendIpConfigurationId interface{}
	// The name of the frontend IP configuration exposing this rule.
	FrontendIpConfigurationName interface{}
	// 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 interface{}
	// The ID of the Load Balancer in which to create the NAT Rule.
	LoadbalancerId interface{}
	Location       interface{}
	// Specifies the name of the NAT Rule.
	Name interface{}
	// The transport protocol for the external endpoint. Possible values are `Udp`, `Tcp` or `All`.
	Protocol interface{}
	// The name of the resource group in which to create the resource.
	ResourceGroupName interface{}
}

Input properties used for looking up and filtering NatRule resources.

type Probe 

type Probe struct {
	// contains filtered or unexported fields
}

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.ID, state *ProbeState, opts ...pulumi.ResourceOpt) (*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.ResourceOpt) (*Probe, error)

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

func (*Probe) ID 

func (r *Probe) ID() *pulumi.IDOutput

ID is this resource's unique identifier assigned by its provider.

func (*Probe) IntervalInSeconds 

func (r *Probe) IntervalInSeconds() *pulumi.IntOutput

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

func (*Probe) LoadBalancerRules 

func (r *Probe) LoadBalancerRules() *pulumi.ArrayOutput

func (*Probe) LoadbalancerId 

func (r *Probe) LoadbalancerId() *pulumi.StringOutput

The ID of the LoadBalancer in which to create the NAT Rule.

func (*Probe) Location 

func (r *Probe) Location() *pulumi.StringOutput

func (*Probe) Name 

func (r *Probe) Name() *pulumi.StringOutput

Specifies the name of the Probe.

func (*Probe) NumberOfProbes 

func (r *Probe) NumberOfProbes() *pulumi.IntOutput

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.

func (*Probe) Port 

func (r *Probe) Port() *pulumi.IntOutput

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

func (*Probe) Protocol 

func (r *Probe) Protocol() *pulumi.StringOutput

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.

func (*Probe) RequestPath 

func (r *Probe) RequestPath() *pulumi.StringOutput

The URI used for requesting health status from the backend endpoint. Required if protocol is set to Http. Otherwise, it is not allowed.

func (*Probe) ResourceGroupName 

func (r *Probe) ResourceGroupName() *pulumi.StringOutput

The name of the resource group in which to create the resource.

func (*Probe) URN 

func (r *Probe) URN() *pulumi.URNOutput

URN is this resource's unique name assigned by Pulumi.

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 interface{}
	// The ID of the LoadBalancer in which to create the NAT Rule.
	LoadbalancerId interface{}
	Location       interface{}
	// Specifies the name of the Probe.
	Name interface{}
	// 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 interface{}
	// Port on which the Probe queries the backend endpoint. Possible values range from 1 to 65535, inclusive.
	Port interface{}
	// 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 interface{}
	// The URI used for requesting health status from the backend endpoint. Required if protocol is set to Http. Otherwise, it is not allowed.
	RequestPath interface{}
	// The name of the resource group in which to create the resource.
	ResourceGroupName interface{}
}

The set of arguments for constructing a Probe resource.

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 interface{}
	LoadBalancerRules interface{}
	// The ID of the LoadBalancer in which to create the NAT Rule.
	LoadbalancerId interface{}
	Location       interface{}
	// Specifies the name of the Probe.
	Name interface{}
	// 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 interface{}
	// Port on which the Probe queries the backend endpoint. Possible values range from 1 to 65535, inclusive.
	Port interface{}
	// 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 interface{}
	// The URI used for requesting health status from the backend endpoint. Required if protocol is set to Http. Otherwise, it is not allowed.
	RequestPath interface{}
	// The name of the resource group in which to create the resource.
	ResourceGroupName interface{}
}

Input properties used for looking up and filtering Probe resources.

type Rule 

type Rule struct {
	// contains filtered or unexported fields
}

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.ID, state *RuleState, opts ...pulumi.ResourceOpt) (*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.ResourceOpt) (*Rule, error)

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

func (*Rule) BackendAddressPoolId 

func (r *Rule) BackendAddressPoolId() *pulumi.StringOutput

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

func (*Rule) BackendPort 

func (r *Rule) BackendPort() *pulumi.IntOutput

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

func (*Rule) EnableFloatingIp 

func (r *Rule) EnableFloatingIp() *pulumi.BoolOutput

Floating IP is pertinent to failover scenarios: a "floating” IP is reassigned to a secondary server in case the primary server fails. Floating IP is required for SQL AlwaysOn.

func (*Rule) FrontendIpConfigurationId 

func (r *Rule) FrontendIpConfigurationId() *pulumi.StringOutput

func (*Rule) FrontendIpConfigurationName 

func (r *Rule) FrontendIpConfigurationName() *pulumi.StringOutput

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

func (*Rule) FrontendPort 

func (r *Rule) 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.

func (*Rule) ID 

func (r *Rule) ID() *pulumi.IDOutput

ID is this resource's unique identifier assigned by its provider.

func (*Rule) IdleTimeoutInMinutes 

func (r *Rule) IdleTimeoutInMinutes() *pulumi.IntOutput

Specifies the timeout for the Tcp idle connection. The value can be set between 4 and 30 minutes. The default value is 4 minutes. This element is only used when the protocol is set to Tcp.

func (*Rule) LoadDistribution 

func (r *Rule) 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 the options are called `None`, `Client IP` and `Client IP and Protocol` respectively.

func (*Rule) LoadbalancerId 

func (r *Rule) LoadbalancerId() *pulumi.StringOutput

The ID of the Load Balancer in which to create the Rule.

func (*Rule) Location 

func (r *Rule) Location() *pulumi.StringOutput

func (*Rule) Name 

func (r *Rule) Name() *pulumi.StringOutput

Specifies the name of the LB Rule.

func (*Rule) ProbeId 

func (r *Rule) ProbeId() *pulumi.StringOutput

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

func (*Rule) Protocol 

func (r *Rule) Protocol() *pulumi.StringOutput

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

func (*Rule) ResourceGroupName 

func (r *Rule) ResourceGroupName() *pulumi.StringOutput

The name of the resource group in which to create the resource.

func (*Rule) URN 

func (r *Rule) URN() *pulumi.URNOutput

URN is this resource's unique name assigned by Pulumi.

type RuleArgs 

type RuleArgs struct {
	// A reference to a Backend Address Pool over which this Load Balancing Rule operates.
	BackendAddressPoolId interface{}
	// The port used for internal connections on the endpoint. Possible values range between 0 and 65535, inclusive.
	BackendPort interface{}
	// Floating IP is pertinent to failover scenarios: a "floating” IP is reassigned to a secondary server in case the primary server fails. Floating IP is required for SQL AlwaysOn.
	EnableFloatingIp interface{}
	// The name of the frontend IP configuration to which the rule is associated.
	FrontendIpConfigurationName interface{}
	// 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 interface{}
	// Specifies the timeout for the Tcp idle connection. The value can be set between 4 and 30 minutes. The default value is 4 minutes. This element is only used when the protocol is set to Tcp.
	IdleTimeoutInMinutes interface{}
	// 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 interface{}
	// The ID of the Load Balancer in which to create the Rule.
	LoadbalancerId interface{}
	Location       interface{}
	// Specifies the name of the LB Rule.
	Name interface{}
	// A reference to a Probe used by this Load Balancing Rule.
	ProbeId interface{}
	// The transport protocol for the external endpoint. Possible values are `Tcp`, `Udp` or `All`.
	Protocol interface{}
	// The name of the resource group in which to create the resource.
	ResourceGroupName interface{}
}

The set of arguments for constructing a Rule resource.

type RuleState 

type RuleState struct {
	// A reference to a Backend Address Pool over which this Load Balancing Rule operates.
	BackendAddressPoolId interface{}
	// The port used for internal connections on the endpoint. Possible values range between 0 and 65535, inclusive.
	BackendPort interface{}
	// Floating IP is pertinent to failover scenarios: a "floating” IP is reassigned to a secondary server in case the primary server fails. Floating IP is required for SQL AlwaysOn.
	EnableFloatingIp          interface{}
	FrontendIpConfigurationId interface{}
	// The name of the frontend IP configuration to which the rule is associated.
	FrontendIpConfigurationName interface{}
	// 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 interface{}
	// Specifies the timeout for the Tcp idle connection. The value can be set between 4 and 30 minutes. The default value is 4 minutes. This element is only used when the protocol is set to Tcp.
	IdleTimeoutInMinutes interface{}
	// 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 interface{}
	// The ID of the Load Balancer in which to create the Rule.
	LoadbalancerId interface{}
	Location       interface{}
	// Specifies the name of the LB Rule.
	Name interface{}
	// A reference to a Probe used by this Load Balancing Rule.
	ProbeId interface{}
	// The transport protocol for the external endpoint. Possible values are `Tcp`, `Udp` or `All`.
	Protocol interface{}
	// The name of the resource group in which to create the resource.
	ResourceGroupName interface{}
}

Input properties used for looking up and filtering Rule resources.

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.