networkloadbalancer

package
v2.10.0 Latest Latest
Warning

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

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

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Backend 

type Backend struct {
	pulumi.CustomResourceState

	// The name of the backend set to which to add the backend server.  Example: `exampleBackendSet`
	BackendSetName pulumi.StringOutput `pulumi:"backendSetName"`
	// The IP address of the backend server. Example: `10.0.0.3`
	IpAddress pulumi.StringOutput `pulumi:"ipAddress"`
	// (Updatable) Whether the network load balancer should treat this server as a backup unit. If `true`, then the network load balancer forwards no ingress traffic to this backend server unless all other backend servers not marked as "isBackup" fail the health check policy.  Example: `false`
	IsBackup pulumi.BoolOutput `pulumi:"isBackup"`
	// (Updatable) Whether the network load balancer should drain this server. Servers marked "isDrain" receive no incoming traffic.  Example: `false`
	IsDrain pulumi.BoolOutput `pulumi:"isDrain"`
	// (Updatable) Whether the network load balancer should treat this server as offline. Offline servers receive no incoming traffic.  Example: `false`
	IsOffline pulumi.BoolOutput `pulumi:"isOffline"`
	// Optional unique name identifying the backend within the backend set. If not specified, then one will be generated. Example: `webServer1`
	Name pulumi.StringOutput `pulumi:"name"`
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId pulumi.StringOutput `pulumi:"networkLoadBalancerId"`
	// The communication port for the backend server.  Example: `8080`
	Port pulumi.IntOutput `pulumi:"port"`
	// The IP OCID/Instance OCID associated with the backend server. Example: `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>`
	TargetId pulumi.StringOutput `pulumi:"targetId"`
	// (Updatable) The network load balancing policy weight assigned to the server. Backend servers with a higher weight receive a larger proportion of incoming traffic. For example, a server weighted '3' receives three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/introducton.htm#Policies).  Example: `3`
	//
	// ** IMPORTANT **
	// Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
	Weight pulumi.IntOutput `pulumi:"weight"`
}

This resource provides the Backend resource in Oracle Cloud Infrastructure Network Load Balancer service.

Adds a backend server to a backend set.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-oci/sdk/v2/go/oci/NetworkLoadBalancer"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := NetworkLoadBalancer.NewBackend(ctx, "test_backend", &NetworkLoadBalancer.BackendArgs{
			BackendSetName:        pulumi.Any(testBackendSet.Name),
			NetworkLoadBalancerId: pulumi.Any(testNetworkLoadBalancer.Id),
			Port:                  pulumi.Any(backendPort),
			IpAddress:             pulumi.Any(backendIpAddress),
			IsBackup:              pulumi.Any(backendIsBackup),
			IsDrain:               pulumi.Any(backendIsDrain),
			IsOffline:             pulumi.Any(backendIsOffline),
			Name:                  pulumi.Any(backendName),
			TargetId:              pulumi.Any(testTarget.Id),
			Weight:                pulumi.Any(backendWeight),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Backends can be imported using the `id`, e.g.

```sh $ pulumi import oci:NetworkLoadBalancer/backend:Backend test_backend "networkLoadBalancers/{networkLoadBalancerId}/backendSets/{backendSetName}/backends/{backendName}" ```

func GetBackend 

func GetBackend(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *BackendState, opts ...pulumi.ResourceOption) (*Backend, error)

GetBackend gets an existing Backend 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 NewBackend 

func NewBackend(ctx *pulumi.Context,
	name string, args *BackendArgs, opts ...pulumi.ResourceOption) (*Backend, error)

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

func (*Backend) ElementType 

func (*Backend) ElementType() reflect.Type

func (*Backend) ToBackendOutput 

func (i *Backend) ToBackendOutput() BackendOutput

func (*Backend) ToBackendOutputWithContext 

func (i *Backend) ToBackendOutputWithContext(ctx context.Context) BackendOutput

type BackendArgs 

type BackendArgs struct {
	// The name of the backend set to which to add the backend server.  Example: `exampleBackendSet`
	BackendSetName pulumi.StringInput
	// The IP address of the backend server. Example: `10.0.0.3`
	IpAddress pulumi.StringPtrInput
	// (Updatable) Whether the network load balancer should treat this server as a backup unit. If `true`, then the network load balancer forwards no ingress traffic to this backend server unless all other backend servers not marked as "isBackup" fail the health check policy.  Example: `false`
	IsBackup pulumi.BoolPtrInput
	// (Updatable) Whether the network load balancer should drain this server. Servers marked "isDrain" receive no incoming traffic.  Example: `false`
	IsDrain pulumi.BoolPtrInput
	// (Updatable) Whether the network load balancer should treat this server as offline. Offline servers receive no incoming traffic.  Example: `false`
	IsOffline pulumi.BoolPtrInput
	// Optional unique name identifying the backend within the backend set. If not specified, then one will be generated. Example: `webServer1`
	Name pulumi.StringPtrInput
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId pulumi.StringInput
	// The communication port for the backend server.  Example: `8080`
	Port pulumi.IntInput
	// The IP OCID/Instance OCID associated with the backend server. Example: `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>`
	TargetId pulumi.StringPtrInput
	// (Updatable) The network load balancing policy weight assigned to the server. Backend servers with a higher weight receive a larger proportion of incoming traffic. For example, a server weighted '3' receives three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/introducton.htm#Policies).  Example: `3`
	//
	// ** IMPORTANT **
	// Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
	Weight pulumi.IntPtrInput
}

The set of arguments for constructing a Backend resource.

func (BackendArgs) ElementType 

func (BackendArgs) ElementType() reflect.Type

type BackendArray 

type BackendArray []BackendInput

func (BackendArray) ElementType 

func (BackendArray) ElementType() reflect.Type

func (BackendArray) ToBackendArrayOutput 

func (i BackendArray) ToBackendArrayOutput() BackendArrayOutput

func (BackendArray) ToBackendArrayOutputWithContext 

func (i BackendArray) ToBackendArrayOutputWithContext(ctx context.Context) BackendArrayOutput

type BackendArrayInput 

type BackendArrayInput interface {
	pulumi.Input

	ToBackendArrayOutput() BackendArrayOutput
	ToBackendArrayOutputWithContext(context.Context) BackendArrayOutput
}

BackendArrayInput is an input type that accepts BackendArray and BackendArrayOutput values. You can construct a concrete instance of `BackendArrayInput` via: 

BackendArray{ BackendArgs{...} }

type BackendArrayOutput 

type BackendArrayOutput struct{ *pulumi.OutputState }

func (BackendArrayOutput) ElementType 

func (BackendArrayOutput) ElementType() reflect.Type

func (BackendArrayOutput) Index 

func (o BackendArrayOutput) Index(i pulumi.IntInput) BackendOutput

func (BackendArrayOutput) ToBackendArrayOutput 

func (o BackendArrayOutput) ToBackendArrayOutput() BackendArrayOutput

func (BackendArrayOutput) ToBackendArrayOutputWithContext 

func (o BackendArrayOutput) ToBackendArrayOutputWithContext(ctx context.Context) BackendArrayOutput

type BackendInput 

type BackendInput interface {
	pulumi.Input

	ToBackendOutput() BackendOutput
	ToBackendOutputWithContext(ctx context.Context) BackendOutput
}

type BackendMap 

type BackendMap map[string]BackendInput

func (BackendMap) ElementType 

func (BackendMap) ElementType() reflect.Type

func (BackendMap) ToBackendMapOutput 

func (i BackendMap) ToBackendMapOutput() BackendMapOutput

func (BackendMap) ToBackendMapOutputWithContext 

func (i BackendMap) ToBackendMapOutputWithContext(ctx context.Context) BackendMapOutput

type BackendMapInput 

type BackendMapInput interface {
	pulumi.Input

	ToBackendMapOutput() BackendMapOutput
	ToBackendMapOutputWithContext(context.Context) BackendMapOutput
}

BackendMapInput is an input type that accepts BackendMap and BackendMapOutput values. You can construct a concrete instance of `BackendMapInput` via: 

BackendMap{ "key": BackendArgs{...} }

type BackendMapOutput 

type BackendMapOutput struct{ *pulumi.OutputState }

func (BackendMapOutput) ElementType 

func (BackendMapOutput) ElementType() reflect.Type

func (BackendMapOutput) MapIndex 

func (o BackendMapOutput) MapIndex(k pulumi.StringInput) BackendOutput

func (BackendMapOutput) ToBackendMapOutput 

func (o BackendMapOutput) ToBackendMapOutput() BackendMapOutput

func (BackendMapOutput) ToBackendMapOutputWithContext 

func (o BackendMapOutput) ToBackendMapOutputWithContext(ctx context.Context) BackendMapOutput

type BackendOutput 

type BackendOutput struct{ *pulumi.OutputState }

func (BackendOutput) BackendSetName 

func (o BackendOutput) BackendSetName() pulumi.StringOutput

The name of the backend set to which to add the backend server. Example: `exampleBackendSet`

func (BackendOutput) ElementType 

func (BackendOutput) ElementType() reflect.Type

func (BackendOutput) IpAddress 

func (o BackendOutput) IpAddress() pulumi.StringOutput

The IP address of the backend server. Example: `10.0.0.3`

func (BackendOutput) IsBackup 

func (o BackendOutput) IsBackup() pulumi.BoolOutput

(Updatable) Whether the network load balancer should treat this server as a backup unit. If `true`, then the network load balancer forwards no ingress traffic to this backend server unless all other backend servers not marked as "isBackup" fail the health check policy. Example: `false`

func (BackendOutput) IsDrain 

func (o BackendOutput) IsDrain() pulumi.BoolOutput

(Updatable) Whether the network load balancer should drain this server. Servers marked "isDrain" receive no incoming traffic. Example: `false`

func (BackendOutput) IsOffline 

func (o BackendOutput) IsOffline() pulumi.BoolOutput

(Updatable) Whether the network load balancer should treat this server as offline. Offline servers receive no incoming traffic. Example: `false`

func (BackendOutput) Name 

func (o BackendOutput) Name() pulumi.StringOutput

Optional unique name identifying the backend within the backend set. If not specified, then one will be generated. Example: `webServer1`

func (BackendOutput) NetworkLoadBalancerId 

func (o BackendOutput) NetworkLoadBalancerId() pulumi.StringOutput

The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.

func (BackendOutput) Port 

func (o BackendOutput) Port() pulumi.IntOutput

The communication port for the backend server. Example: `8080`

func (BackendOutput) TargetId 

func (o BackendOutput) TargetId() pulumi.StringOutput

The IP OCID/Instance OCID associated with the backend server. Example: `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>`

func (BackendOutput) ToBackendOutput 

func (o BackendOutput) ToBackendOutput() BackendOutput

func (BackendOutput) ToBackendOutputWithContext 

func (o BackendOutput) ToBackendOutputWithContext(ctx context.Context) BackendOutput

func (BackendOutput) Weight 

func (o BackendOutput) Weight() pulumi.IntOutput

(Updatable) The network load balancing policy weight assigned to the server. Backend servers with a higher weight receive a larger proportion of incoming traffic. For example, a server weighted '3' receives three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/introducton.htm#Policies). Example: `3`

** IMPORTANT ** Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values

type BackendSet 

type BackendSet struct {
	pulumi.CustomResourceState

	// (Updatable) An array of backends to be associated with the backend set.
	Backends BackendSetBackendArrayOutput `pulumi:"backends"`
	// (Updatable) The health check policy configuration. For more information, see [Editing Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/Balance/Tasks/editinghealthcheck.htm).
	HealthChecker BackendSetHealthCheckerOutput `pulumi:"healthChecker"`
	// (Updatable) IP version associated with the backend set.
	IpVersion pulumi.StringOutput `pulumi:"ipVersion"`
	// (Updatable) If enabled, the network load balancer will continue to distribute traffic in the configured distribution in the event all backends are unhealthy. The value is false by default.
	IsFailOpen pulumi.BoolOutput `pulumi:"isFailOpen"`
	// (Updatable) If enabled existing connections will be forwarded to an alternative healthy backend as soon as current backend becomes unhealthy.
	IsInstantFailoverEnabled pulumi.BoolOutput `pulumi:"isInstantFailoverEnabled"`
	// (Updatable) If this parameter is enabled, then the network load balancer preserves the source IP of the packet when it is forwarded to backends. Backends see the original source IP. If the isPreserveSourceDestination parameter is enabled for the network load balancer resource, then this parameter cannot be disabled. The value is true by default.
	IsPreserveSource pulumi.BoolOutput `pulumi:"isPreserveSource"`
	// A user-friendly name for the backend set that must be unique and cannot be changed.
	//
	// Valid backend set names include only alphanumeric characters, dashes, and underscores. Backend set names cannot contain spaces. Avoid entering confidential information.
	//
	// Example: `exampleBackendSet`
	Name pulumi.StringOutput `pulumi:"name"`
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId pulumi.StringOutput `pulumi:"networkLoadBalancerId"`
	// (Updatable) The network load balancer policy for the backend set.  Example: `FIVE_TUPLE“
	//
	// ** IMPORTANT **
	// Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
	Policy pulumi.StringOutput `pulumi:"policy"`
}

This resource provides the Backend Set resource in Oracle Cloud Infrastructure Network Load Balancer service.

Adds a backend set to a network load balancer.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-oci/sdk/v2/go/oci/NetworkLoadBalancer"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := NetworkLoadBalancer.NewBackendSet(ctx, "test_backend_set", &NetworkLoadBalancer.BackendSetArgs{
			HealthChecker: &networkloadbalancer.BackendSetHealthCheckerArgs{
				Protocol: pulumi.Any(backendSetHealthCheckerProtocol),
				Dns: &networkloadbalancer.BackendSetHealthCheckerDnsArgs{
					DomainName:        pulumi.Any(testDomain.Name),
					QueryClass:        pulumi.Any(backendSetHealthCheckerDnsQueryClass),
					QueryType:         pulumi.Any(backendSetHealthCheckerDnsQueryType),
					Rcodes:            pulumi.Any(backendSetHealthCheckerDnsRcodes),
					TransportProtocol: pulumi.Any(backendSetHealthCheckerDnsTransportProtocol),
				},
				IntervalInMillis:  pulumi.Any(backendSetHealthCheckerIntervalInMillis),
				Port:              pulumi.Any(backendSetHealthCheckerPort),
				RequestData:       pulumi.Any(backendSetHealthCheckerRequestData),
				ResponseBodyRegex: pulumi.Any(backendSetHealthCheckerResponseBodyRegex),
				ResponseData:      pulumi.Any(backendSetHealthCheckerResponseData),
				Retries:           pulumi.Any(backendSetHealthCheckerRetries),
				ReturnCode:        pulumi.Any(backendSetHealthCheckerReturnCode),
				TimeoutInMillis:   pulumi.Any(backendSetHealthCheckerTimeoutInMillis),
				UrlPath:           pulumi.Any(backendSetHealthCheckerUrlPath),
			},
			Name:                     pulumi.Any(backendSetName),
			NetworkLoadBalancerId:    pulumi.Any(testNetworkLoadBalancer.Id),
			Policy:                   pulumi.Any(backendSetPolicy),
			IpVersion:                pulumi.Any(backendSetIpVersion),
			IsFailOpen:               pulumi.Any(backendSetIsFailOpen),
			IsInstantFailoverEnabled: pulumi.Any(backendSetIsInstantFailoverEnabled),
			IsPreserveSource:         pulumi.Any(backendSetIsPreserveSource),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

BackendSets can be imported using the `id`, e.g.

```sh $ pulumi import oci:NetworkLoadBalancer/backendSet:BackendSet test_backend_set "networkLoadBalancers/{networkLoadBalancerId}/backendSets/{backendSetName}" ```

func GetBackendSet 

func GetBackendSet(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *BackendSetState, opts ...pulumi.ResourceOption) (*BackendSet, error)

GetBackendSet gets an existing BackendSet 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 NewBackendSet 

func NewBackendSet(ctx *pulumi.Context,
	name string, args *BackendSetArgs, opts ...pulumi.ResourceOption) (*BackendSet, error)

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

func (*BackendSet) ElementType 

func (*BackendSet) ElementType() reflect.Type

func (*BackendSet) ToBackendSetOutput 

func (i *BackendSet) ToBackendSetOutput() BackendSetOutput

func (*BackendSet) ToBackendSetOutputWithContext 

func (i *BackendSet) ToBackendSetOutputWithContext(ctx context.Context) BackendSetOutput

type BackendSetArgs 

type BackendSetArgs struct {
	// (Updatable) The health check policy configuration. For more information, see [Editing Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/Balance/Tasks/editinghealthcheck.htm).
	HealthChecker BackendSetHealthCheckerInput
	// (Updatable) IP version associated with the backend set.
	IpVersion pulumi.StringPtrInput
	// (Updatable) If enabled, the network load balancer will continue to distribute traffic in the configured distribution in the event all backends are unhealthy. The value is false by default.
	IsFailOpen pulumi.BoolPtrInput
	// (Updatable) If enabled existing connections will be forwarded to an alternative healthy backend as soon as current backend becomes unhealthy.
	IsInstantFailoverEnabled pulumi.BoolPtrInput
	// (Updatable) If this parameter is enabled, then the network load balancer preserves the source IP of the packet when it is forwarded to backends. Backends see the original source IP. If the isPreserveSourceDestination parameter is enabled for the network load balancer resource, then this parameter cannot be disabled. The value is true by default.
	IsPreserveSource pulumi.BoolPtrInput
	// A user-friendly name for the backend set that must be unique and cannot be changed.
	//
	// Valid backend set names include only alphanumeric characters, dashes, and underscores. Backend set names cannot contain spaces. Avoid entering confidential information.
	//
	// Example: `exampleBackendSet`
	Name pulumi.StringPtrInput
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId pulumi.StringInput
	// (Updatable) The network load balancer policy for the backend set.  Example: `FIVE_TUPLE“
	//
	// ** IMPORTANT **
	// Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
	Policy pulumi.StringInput
}

The set of arguments for constructing a BackendSet resource.

func (BackendSetArgs) ElementType 

func (BackendSetArgs) ElementType() reflect.Type

type BackendSetArray 

type BackendSetArray []BackendSetInput

func (BackendSetArray) ElementType 

func (BackendSetArray) ElementType() reflect.Type

func (BackendSetArray) ToBackendSetArrayOutput 

func (i BackendSetArray) ToBackendSetArrayOutput() BackendSetArrayOutput

func (BackendSetArray) ToBackendSetArrayOutputWithContext 

func (i BackendSetArray) ToBackendSetArrayOutputWithContext(ctx context.Context) BackendSetArrayOutput

type BackendSetArrayInput 

type BackendSetArrayInput interface {
	pulumi.Input

	ToBackendSetArrayOutput() BackendSetArrayOutput
	ToBackendSetArrayOutputWithContext(context.Context) BackendSetArrayOutput
}

BackendSetArrayInput is an input type that accepts BackendSetArray and BackendSetArrayOutput values. You can construct a concrete instance of `BackendSetArrayInput` via: 

BackendSetArray{ BackendSetArgs{...} }

type BackendSetArrayOutput 

type BackendSetArrayOutput struct{ *pulumi.OutputState }

func (BackendSetArrayOutput) ElementType 

func (BackendSetArrayOutput) ElementType() reflect.Type

func (BackendSetArrayOutput) Index 

func (o BackendSetArrayOutput) Index(i pulumi.IntInput) BackendSetOutput

func (BackendSetArrayOutput) ToBackendSetArrayOutput 

func (o BackendSetArrayOutput) ToBackendSetArrayOutput() BackendSetArrayOutput

func (BackendSetArrayOutput) ToBackendSetArrayOutputWithContext 

func (o BackendSetArrayOutput) ToBackendSetArrayOutputWithContext(ctx context.Context) BackendSetArrayOutput

type BackendSetBackend 

type BackendSetBackend struct {
	// (Updatable) The IP address of the backend server.  Example: `10.0.0.3`
	IpAddress *string `pulumi:"ipAddress"`
	// (Updatable) Whether the network load balancer should treat this server as a backup unit. If `true`, then the network load balancer forwards no ingress traffic to this backend server unless all other backend servers not marked as "isBackup" fail the health check policy.  Example: `false`
	IsBackup *bool `pulumi:"isBackup"`
	// (Updatable) Whether the network load balancer should drain this server. Servers marked "isDrain" receive no incoming traffic.  Example: `false`
	IsDrain *bool `pulumi:"isDrain"`
	// (Updatable) Whether the network load balancer should treat this server as offline. Offline servers receive no incoming traffic.  Example: `false`
	IsOffline *bool `pulumi:"isOffline"`
	// (Updatable) A read-only field showing the IP address/OCID and port that uniquely identify this backend server in the backend set.  Example: `10.0.0.3:8080`, or `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>:443` or `10.0.0.3:0`
	Name *string `pulumi:"name"`
	// (Updatable) The communication port for the backend server.  Example: `8080`
	Port int `pulumi:"port"`
	// (Updatable) The IP OCID/Instance OCID associated with the backend server. Example: `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>`
	TargetId *string `pulumi:"targetId"`
	// (Updatable) The network load balancing policy weight assigned to the server. Backend servers with a higher weight receive a larger proportion of incoming traffic. For example, a server weighted '3' receives three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/lbpolicies.htm).  Example: `3`
	Weight *int `pulumi:"weight"`
}

type BackendSetBackendArgs 

type BackendSetBackendArgs struct {
	// (Updatable) The IP address of the backend server.  Example: `10.0.0.3`
	IpAddress pulumi.StringPtrInput `pulumi:"ipAddress"`
	// (Updatable) Whether the network load balancer should treat this server as a backup unit. If `true`, then the network load balancer forwards no ingress traffic to this backend server unless all other backend servers not marked as "isBackup" fail the health check policy.  Example: `false`
	IsBackup pulumi.BoolPtrInput `pulumi:"isBackup"`
	// (Updatable) Whether the network load balancer should drain this server. Servers marked "isDrain" receive no incoming traffic.  Example: `false`
	IsDrain pulumi.BoolPtrInput `pulumi:"isDrain"`
	// (Updatable) Whether the network load balancer should treat this server as offline. Offline servers receive no incoming traffic.  Example: `false`
	IsOffline pulumi.BoolPtrInput `pulumi:"isOffline"`
	// (Updatable) A read-only field showing the IP address/OCID and port that uniquely identify this backend server in the backend set.  Example: `10.0.0.3:8080`, or `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>:443` or `10.0.0.3:0`
	Name pulumi.StringPtrInput `pulumi:"name"`
	// (Updatable) The communication port for the backend server.  Example: `8080`
	Port pulumi.IntInput `pulumi:"port"`
	// (Updatable) The IP OCID/Instance OCID associated with the backend server. Example: `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>`
	TargetId pulumi.StringPtrInput `pulumi:"targetId"`
	// (Updatable) The network load balancing policy weight assigned to the server. Backend servers with a higher weight receive a larger proportion of incoming traffic. For example, a server weighted '3' receives three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/lbpolicies.htm).  Example: `3`
	Weight pulumi.IntPtrInput `pulumi:"weight"`
}

func (BackendSetBackendArgs) ElementType 

func (BackendSetBackendArgs) ElementType() reflect.Type

func (BackendSetBackendArgs) ToBackendSetBackendOutput 

func (i BackendSetBackendArgs) ToBackendSetBackendOutput() BackendSetBackendOutput

func (BackendSetBackendArgs) ToBackendSetBackendOutputWithContext 

func (i BackendSetBackendArgs) ToBackendSetBackendOutputWithContext(ctx context.Context) BackendSetBackendOutput

type BackendSetBackendArray 

type BackendSetBackendArray []BackendSetBackendInput

func (BackendSetBackendArray) ElementType 

func (BackendSetBackendArray) ElementType() reflect.Type

func (BackendSetBackendArray) ToBackendSetBackendArrayOutput 

func (i BackendSetBackendArray) ToBackendSetBackendArrayOutput() BackendSetBackendArrayOutput

func (BackendSetBackendArray) ToBackendSetBackendArrayOutputWithContext 

func (i BackendSetBackendArray) ToBackendSetBackendArrayOutputWithContext(ctx context.Context) BackendSetBackendArrayOutput

type BackendSetBackendArrayInput 

type BackendSetBackendArrayInput interface {
	pulumi.Input

	ToBackendSetBackendArrayOutput() BackendSetBackendArrayOutput
	ToBackendSetBackendArrayOutputWithContext(context.Context) BackendSetBackendArrayOutput
}

BackendSetBackendArrayInput is an input type that accepts BackendSetBackendArray and BackendSetBackendArrayOutput values. You can construct a concrete instance of `BackendSetBackendArrayInput` via: 

BackendSetBackendArray{ BackendSetBackendArgs{...} }

type BackendSetBackendArrayOutput 

type BackendSetBackendArrayOutput struct{ *pulumi.OutputState }

func (BackendSetBackendArrayOutput) ElementType 

func (BackendSetBackendArrayOutput) ElementType() reflect.Type

func (BackendSetBackendArrayOutput) Index 

func (o BackendSetBackendArrayOutput) Index(i pulumi.IntInput) BackendSetBackendOutput

func (BackendSetBackendArrayOutput) ToBackendSetBackendArrayOutput 

func (o BackendSetBackendArrayOutput) ToBackendSetBackendArrayOutput() BackendSetBackendArrayOutput

func (BackendSetBackendArrayOutput) ToBackendSetBackendArrayOutputWithContext 

func (o BackendSetBackendArrayOutput) ToBackendSetBackendArrayOutputWithContext(ctx context.Context) BackendSetBackendArrayOutput

type BackendSetBackendInput 

type BackendSetBackendInput interface {
	pulumi.Input

	ToBackendSetBackendOutput() BackendSetBackendOutput
	ToBackendSetBackendOutputWithContext(context.Context) BackendSetBackendOutput
}

BackendSetBackendInput is an input type that accepts BackendSetBackendArgs and BackendSetBackendOutput values. You can construct a concrete instance of `BackendSetBackendInput` via: 

BackendSetBackendArgs{...}

type BackendSetBackendOutput 

type BackendSetBackendOutput struct{ *pulumi.OutputState }

func (BackendSetBackendOutput) ElementType 

func (BackendSetBackendOutput) ElementType() reflect.Type

func (BackendSetBackendOutput) IpAddress 

func (o BackendSetBackendOutput) IpAddress() pulumi.StringPtrOutput

(Updatable) The IP address of the backend server. Example: `10.0.0.3`

func (BackendSetBackendOutput) IsBackup 

func (o BackendSetBackendOutput) IsBackup() pulumi.BoolPtrOutput

(Updatable) Whether the network load balancer should treat this server as a backup unit. If `true`, then the network load balancer forwards no ingress traffic to this backend server unless all other backend servers not marked as "isBackup" fail the health check policy. Example: `false`

func (BackendSetBackendOutput) IsDrain 

func (o BackendSetBackendOutput) IsDrain() pulumi.BoolPtrOutput

(Updatable) Whether the network load balancer should drain this server. Servers marked "isDrain" receive no incoming traffic. Example: `false`

func (BackendSetBackendOutput) IsOffline 

func (o BackendSetBackendOutput) IsOffline() pulumi.BoolPtrOutput

(Updatable) Whether the network load balancer should treat this server as offline. Offline servers receive no incoming traffic. Example: `false`

func (BackendSetBackendOutput) Name 

func (o BackendSetBackendOutput) Name() pulumi.StringPtrOutput

(Updatable) A read-only field showing the IP address/OCID and port that uniquely identify this backend server in the backend set. Example: `10.0.0.3:8080`, or `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>:443` or `10.0.0.3:0`

func (BackendSetBackendOutput) Port 

func (o BackendSetBackendOutput) Port() pulumi.IntOutput

(Updatable) The communication port for the backend server. Example: `8080`

func (BackendSetBackendOutput) TargetId 

func (o BackendSetBackendOutput) TargetId() pulumi.StringPtrOutput

(Updatable) The IP OCID/Instance OCID associated with the backend server. Example: `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>`

func (BackendSetBackendOutput) ToBackendSetBackendOutput 

func (o BackendSetBackendOutput) ToBackendSetBackendOutput() BackendSetBackendOutput

func (BackendSetBackendOutput) ToBackendSetBackendOutputWithContext 

func (o BackendSetBackendOutput) ToBackendSetBackendOutputWithContext(ctx context.Context) BackendSetBackendOutput

func (BackendSetBackendOutput) Weight 

func (o BackendSetBackendOutput) Weight() pulumi.IntPtrOutput

(Updatable) The network load balancing policy weight assigned to the server. Backend servers with a higher weight receive a larger proportion of incoming traffic. For example, a server weighted '3' receives three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/lbpolicies.htm). Example: `3`

type BackendSetHealthChecker 

type BackendSetHealthChecker struct {
	// (Updatable) DNS healthcheck configurations.
	Dns *BackendSetHealthCheckerDns `pulumi:"dns"`
	// (Updatable) The interval between health checks, in milliseconds. The default value is 10000 (10 seconds).  Example: `10000`
	IntervalInMillis *int `pulumi:"intervalInMillis"`
	// (Updatable) The backend server port against which to run the health check. If the port is not specified, then the network load balancer uses the port information from the `Backend` object. The port must be specified if the backend port is 0.  Example: `8080`
	Port *int `pulumi:"port"`
	// (Updatable) The protocol the health check must use; either HTTP, HTTPS, UDP, TCP or DNS.  Example: `HTTP`
	Protocol string `pulumi:"protocol"`
	// (Updatable) Base64 encoded pattern to be sent as UDP or TCP health check probe.
	RequestData *string `pulumi:"requestData"`
	// (Updatable) A regular expression for parsing the response body from the backend server.  Example: `^((?!false).|\s)*$`
	ResponseBodyRegex *string `pulumi:"responseBodyRegex"`
	// (Updatable) Base64 encoded pattern to be validated as UDP or TCP health check probe response.
	ResponseData *string `pulumi:"responseData"`
	// (Updatable) The number of retries to attempt before a backend server is considered "unhealthy". This number also applies when recovering a server to the "healthy" state. The default value is 3.  Example: `3`
	Retries *int `pulumi:"retries"`
	// (Updatable) The status code a healthy backend server should return. If you configure the health check policy to use the HTTP protocol, then you can use common HTTP status codes such as "200".  Example: `200`
	ReturnCode *int `pulumi:"returnCode"`
	// (Updatable) The maximum time, in milliseconds, to wait for a reply to a health check. A health check is successful only if a reply returns within this timeout period. The default value is 3000 (3 seconds).  Example: `3000`
	TimeoutInMillis *int `pulumi:"timeoutInMillis"`
	// (Updatable) The path against which to run the health check.  Example: `/healthcheck`
	UrlPath *string `pulumi:"urlPath"`
}

type BackendSetHealthCheckerArgs 

type BackendSetHealthCheckerArgs struct {
	// (Updatable) DNS healthcheck configurations.
	Dns BackendSetHealthCheckerDnsPtrInput `pulumi:"dns"`
	// (Updatable) The interval between health checks, in milliseconds. The default value is 10000 (10 seconds).  Example: `10000`
	IntervalInMillis pulumi.IntPtrInput `pulumi:"intervalInMillis"`
	// (Updatable) The backend server port against which to run the health check. If the port is not specified, then the network load balancer uses the port information from the `Backend` object. The port must be specified if the backend port is 0.  Example: `8080`
	Port pulumi.IntPtrInput `pulumi:"port"`
	// (Updatable) The protocol the health check must use; either HTTP, HTTPS, UDP, TCP or DNS.  Example: `HTTP`
	Protocol pulumi.StringInput `pulumi:"protocol"`
	// (Updatable) Base64 encoded pattern to be sent as UDP or TCP health check probe.
	RequestData pulumi.StringPtrInput `pulumi:"requestData"`
	// (Updatable) A regular expression for parsing the response body from the backend server.  Example: `^((?!false).|\s)*$`
	ResponseBodyRegex pulumi.StringPtrInput `pulumi:"responseBodyRegex"`
	// (Updatable) Base64 encoded pattern to be validated as UDP or TCP health check probe response.
	ResponseData pulumi.StringPtrInput `pulumi:"responseData"`
	// (Updatable) The number of retries to attempt before a backend server is considered "unhealthy". This number also applies when recovering a server to the "healthy" state. The default value is 3.  Example: `3`
	Retries pulumi.IntPtrInput `pulumi:"retries"`
	// (Updatable) The status code a healthy backend server should return. If you configure the health check policy to use the HTTP protocol, then you can use common HTTP status codes such as "200".  Example: `200`
	ReturnCode pulumi.IntPtrInput `pulumi:"returnCode"`
	// (Updatable) The maximum time, in milliseconds, to wait for a reply to a health check. A health check is successful only if a reply returns within this timeout period. The default value is 3000 (3 seconds).  Example: `3000`
	TimeoutInMillis pulumi.IntPtrInput `pulumi:"timeoutInMillis"`
	// (Updatable) The path against which to run the health check.  Example: `/healthcheck`
	UrlPath pulumi.StringPtrInput `pulumi:"urlPath"`
}

func (BackendSetHealthCheckerArgs) ElementType 

func (BackendSetHealthCheckerArgs) ElementType() reflect.Type

func (BackendSetHealthCheckerArgs) ToBackendSetHealthCheckerOutput 

func (i BackendSetHealthCheckerArgs) ToBackendSetHealthCheckerOutput() BackendSetHealthCheckerOutput

func (BackendSetHealthCheckerArgs) ToBackendSetHealthCheckerOutputWithContext 

func (i BackendSetHealthCheckerArgs) ToBackendSetHealthCheckerOutputWithContext(ctx context.Context) BackendSetHealthCheckerOutput

func (BackendSetHealthCheckerArgs) ToBackendSetHealthCheckerPtrOutput 

func (i BackendSetHealthCheckerArgs) ToBackendSetHealthCheckerPtrOutput() BackendSetHealthCheckerPtrOutput

func (BackendSetHealthCheckerArgs) ToBackendSetHealthCheckerPtrOutputWithContext 

func (i BackendSetHealthCheckerArgs) ToBackendSetHealthCheckerPtrOutputWithContext(ctx context.Context) BackendSetHealthCheckerPtrOutput

type BackendSetHealthCheckerDns 

type BackendSetHealthCheckerDns struct {
	// (Updatable) The absolute fully-qualified domain name to perform periodic DNS queries. If not provided, an extra dot will be added at the end of a domain name during the query.
	DomainName string `pulumi:"domainName"`
	// (Updatable) The class the dns health check query to use; either IN or CH.  Example: `IN`
	QueryClass *string `pulumi:"queryClass"`
	// (Updatable) The type the dns health check query to use; A, AAAA, TXT.  Example: `A`
	QueryType *string `pulumi:"queryType"`
	// (Updatable) An array that represents accepetable RCODE values for DNS query response. Example: ["NOERROR", "NXDOMAIN"]
	Rcodes []string `pulumi:"rcodes"`
	// (Updatable) DNS transport protocol; either UDP or TCP.  Example: `UDP`
	TransportProtocol *string `pulumi:"transportProtocol"`
}

type BackendSetHealthCheckerDnsArgs 

type BackendSetHealthCheckerDnsArgs struct {
	// (Updatable) The absolute fully-qualified domain name to perform periodic DNS queries. If not provided, an extra dot will be added at the end of a domain name during the query.
	DomainName pulumi.StringInput `pulumi:"domainName"`
	// (Updatable) The class the dns health check query to use; either IN or CH.  Example: `IN`
	QueryClass pulumi.StringPtrInput `pulumi:"queryClass"`
	// (Updatable) The type the dns health check query to use; A, AAAA, TXT.  Example: `A`
	QueryType pulumi.StringPtrInput `pulumi:"queryType"`
	// (Updatable) An array that represents accepetable RCODE values for DNS query response. Example: ["NOERROR", "NXDOMAIN"]
	Rcodes pulumi.StringArrayInput `pulumi:"rcodes"`
	// (Updatable) DNS transport protocol; either UDP or TCP.  Example: `UDP`
	TransportProtocol pulumi.StringPtrInput `pulumi:"transportProtocol"`
}

func (BackendSetHealthCheckerDnsArgs) ElementType 

func (BackendSetHealthCheckerDnsArgs) ElementType() reflect.Type

func (BackendSetHealthCheckerDnsArgs) ToBackendSetHealthCheckerDnsOutput 

func (i BackendSetHealthCheckerDnsArgs) ToBackendSetHealthCheckerDnsOutput() BackendSetHealthCheckerDnsOutput

func (BackendSetHealthCheckerDnsArgs) ToBackendSetHealthCheckerDnsOutputWithContext 

func (i BackendSetHealthCheckerDnsArgs) ToBackendSetHealthCheckerDnsOutputWithContext(ctx context.Context) BackendSetHealthCheckerDnsOutput

func (BackendSetHealthCheckerDnsArgs) ToBackendSetHealthCheckerDnsPtrOutput 

func (i BackendSetHealthCheckerDnsArgs) ToBackendSetHealthCheckerDnsPtrOutput() BackendSetHealthCheckerDnsPtrOutput

func (BackendSetHealthCheckerDnsArgs) ToBackendSetHealthCheckerDnsPtrOutputWithContext 

func (i BackendSetHealthCheckerDnsArgs) ToBackendSetHealthCheckerDnsPtrOutputWithContext(ctx context.Context) BackendSetHealthCheckerDnsPtrOutput

type BackendSetHealthCheckerDnsInput 

type BackendSetHealthCheckerDnsInput interface {
	pulumi.Input

	ToBackendSetHealthCheckerDnsOutput() BackendSetHealthCheckerDnsOutput
	ToBackendSetHealthCheckerDnsOutputWithContext(context.Context) BackendSetHealthCheckerDnsOutput
}

BackendSetHealthCheckerDnsInput is an input type that accepts BackendSetHealthCheckerDnsArgs and BackendSetHealthCheckerDnsOutput values. You can construct a concrete instance of `BackendSetHealthCheckerDnsInput` via: 

BackendSetHealthCheckerDnsArgs{...}

type BackendSetHealthCheckerDnsOutput 

type BackendSetHealthCheckerDnsOutput struct{ *pulumi.OutputState }

func (BackendSetHealthCheckerDnsOutput) DomainName 

func (o BackendSetHealthCheckerDnsOutput) DomainName() pulumi.StringOutput

(Updatable) The absolute fully-qualified domain name to perform periodic DNS queries. If not provided, an extra dot will be added at the end of a domain name during the query.

func (BackendSetHealthCheckerDnsOutput) ElementType 

func (BackendSetHealthCheckerDnsOutput) ElementType() reflect.Type

func (BackendSetHealthCheckerDnsOutput) QueryClass 

func (o BackendSetHealthCheckerDnsOutput) QueryClass() pulumi.StringPtrOutput

(Updatable) The class the dns health check query to use; either IN or CH. Example: `IN`

func (BackendSetHealthCheckerDnsOutput) QueryType 

func (o BackendSetHealthCheckerDnsOutput) QueryType() pulumi.StringPtrOutput

(Updatable) The type the dns health check query to use; A, AAAA, TXT. Example: `A`

func (BackendSetHealthCheckerDnsOutput) Rcodes 

func (o BackendSetHealthCheckerDnsOutput) Rcodes() pulumi.StringArrayOutput

(Updatable) An array that represents accepetable RCODE values for DNS query response. Example: ["NOERROR", "NXDOMAIN"]

func (BackendSetHealthCheckerDnsOutput) ToBackendSetHealthCheckerDnsOutput 

func (o BackendSetHealthCheckerDnsOutput) ToBackendSetHealthCheckerDnsOutput() BackendSetHealthCheckerDnsOutput

func (BackendSetHealthCheckerDnsOutput) ToBackendSetHealthCheckerDnsOutputWithContext 

func (o BackendSetHealthCheckerDnsOutput) ToBackendSetHealthCheckerDnsOutputWithContext(ctx context.Context) BackendSetHealthCheckerDnsOutput

func (BackendSetHealthCheckerDnsOutput) ToBackendSetHealthCheckerDnsPtrOutput 

func (o BackendSetHealthCheckerDnsOutput) ToBackendSetHealthCheckerDnsPtrOutput() BackendSetHealthCheckerDnsPtrOutput

func (BackendSetHealthCheckerDnsOutput) ToBackendSetHealthCheckerDnsPtrOutputWithContext 

func (o BackendSetHealthCheckerDnsOutput) ToBackendSetHealthCheckerDnsPtrOutputWithContext(ctx context.Context) BackendSetHealthCheckerDnsPtrOutput

func (BackendSetHealthCheckerDnsOutput) TransportProtocol 

func (o BackendSetHealthCheckerDnsOutput) TransportProtocol() pulumi.StringPtrOutput

(Updatable) DNS transport protocol; either UDP or TCP. Example: `UDP`

type BackendSetHealthCheckerDnsPtrInput 

type BackendSetHealthCheckerDnsPtrInput interface {
	pulumi.Input

	ToBackendSetHealthCheckerDnsPtrOutput() BackendSetHealthCheckerDnsPtrOutput
	ToBackendSetHealthCheckerDnsPtrOutputWithContext(context.Context) BackendSetHealthCheckerDnsPtrOutput
}

BackendSetHealthCheckerDnsPtrInput is an input type that accepts BackendSetHealthCheckerDnsArgs, BackendSetHealthCheckerDnsPtr and BackendSetHealthCheckerDnsPtrOutput values. You can construct a concrete instance of `BackendSetHealthCheckerDnsPtrInput` via: 

        BackendSetHealthCheckerDnsArgs{...}

or:

        nil

func BackendSetHealthCheckerDnsPtr 

func BackendSetHealthCheckerDnsPtr(v *BackendSetHealthCheckerDnsArgs) BackendSetHealthCheckerDnsPtrInput

type BackendSetHealthCheckerDnsPtrOutput 

type BackendSetHealthCheckerDnsPtrOutput struct{ *pulumi.OutputState }

func (BackendSetHealthCheckerDnsPtrOutput) DomainName 

func (o BackendSetHealthCheckerDnsPtrOutput) DomainName() pulumi.StringPtrOutput

(Updatable) The absolute fully-qualified domain name to perform periodic DNS queries. If not provided, an extra dot will be added at the end of a domain name during the query.

func (BackendSetHealthCheckerDnsPtrOutput) Elem 

func (o BackendSetHealthCheckerDnsPtrOutput) Elem() BackendSetHealthCheckerDnsOutput

func (BackendSetHealthCheckerDnsPtrOutput) ElementType 

func (BackendSetHealthCheckerDnsPtrOutput) ElementType() reflect.Type

func (BackendSetHealthCheckerDnsPtrOutput) QueryClass 

func (o BackendSetHealthCheckerDnsPtrOutput) QueryClass() pulumi.StringPtrOutput

(Updatable) The class the dns health check query to use; either IN or CH. Example: `IN`

func (BackendSetHealthCheckerDnsPtrOutput) QueryType 

func (o BackendSetHealthCheckerDnsPtrOutput) QueryType() pulumi.StringPtrOutput

(Updatable) The type the dns health check query to use; A, AAAA, TXT. Example: `A`

func (BackendSetHealthCheckerDnsPtrOutput) Rcodes 

func (o BackendSetHealthCheckerDnsPtrOutput) Rcodes() pulumi.StringArrayOutput

(Updatable) An array that represents accepetable RCODE values for DNS query response. Example: ["NOERROR", "NXDOMAIN"]

func (BackendSetHealthCheckerDnsPtrOutput) ToBackendSetHealthCheckerDnsPtrOutput 

func (o BackendSetHealthCheckerDnsPtrOutput) ToBackendSetHealthCheckerDnsPtrOutput() BackendSetHealthCheckerDnsPtrOutput

func (BackendSetHealthCheckerDnsPtrOutput) ToBackendSetHealthCheckerDnsPtrOutputWithContext 

func (o BackendSetHealthCheckerDnsPtrOutput) ToBackendSetHealthCheckerDnsPtrOutputWithContext(ctx context.Context) BackendSetHealthCheckerDnsPtrOutput

func (BackendSetHealthCheckerDnsPtrOutput) TransportProtocol 

func (o BackendSetHealthCheckerDnsPtrOutput) TransportProtocol() pulumi.StringPtrOutput

(Updatable) DNS transport protocol; either UDP or TCP. Example: `UDP`

type BackendSetHealthCheckerInput 

type BackendSetHealthCheckerInput interface {
	pulumi.Input

	ToBackendSetHealthCheckerOutput() BackendSetHealthCheckerOutput
	ToBackendSetHealthCheckerOutputWithContext(context.Context) BackendSetHealthCheckerOutput
}

BackendSetHealthCheckerInput is an input type that accepts BackendSetHealthCheckerArgs and BackendSetHealthCheckerOutput values. You can construct a concrete instance of `BackendSetHealthCheckerInput` via: 

BackendSetHealthCheckerArgs{...}

type BackendSetHealthCheckerOutput 

type BackendSetHealthCheckerOutput struct{ *pulumi.OutputState }

func (BackendSetHealthCheckerOutput) Dns 

func (o BackendSetHealthCheckerOutput) Dns() BackendSetHealthCheckerDnsPtrOutput

(Updatable) DNS healthcheck configurations.

func (BackendSetHealthCheckerOutput) ElementType 

func (BackendSetHealthCheckerOutput) ElementType() reflect.Type

func (BackendSetHealthCheckerOutput) IntervalInMillis 

func (o BackendSetHealthCheckerOutput) IntervalInMillis() pulumi.IntPtrOutput

(Updatable) The interval between health checks, in milliseconds. The default value is 10000 (10 seconds). Example: `10000`

func (BackendSetHealthCheckerOutput) Port 

func (o BackendSetHealthCheckerOutput) Port() pulumi.IntPtrOutput

(Updatable) The backend server port against which to run the health check. If the port is not specified, then the network load balancer uses the port information from the `Backend` object. The port must be specified if the backend port is 0. Example: `8080`

func (BackendSetHealthCheckerOutput) Protocol 

func (o BackendSetHealthCheckerOutput) Protocol() pulumi.StringOutput

(Updatable) The protocol the health check must use; either HTTP, HTTPS, UDP, TCP or DNS. Example: `HTTP`

func (BackendSetHealthCheckerOutput) RequestData 

func (o BackendSetHealthCheckerOutput) RequestData() pulumi.StringPtrOutput

(Updatable) Base64 encoded pattern to be sent as UDP or TCP health check probe.

func (BackendSetHealthCheckerOutput) ResponseBodyRegex 

func (o BackendSetHealthCheckerOutput) ResponseBodyRegex() pulumi.StringPtrOutput

(Updatable) A regular expression for parsing the response body from the backend server. Example: `^((?!false).|\s)*$`

func (BackendSetHealthCheckerOutput) ResponseData 

func (o BackendSetHealthCheckerOutput) ResponseData() pulumi.StringPtrOutput

(Updatable) Base64 encoded pattern to be validated as UDP or TCP health check probe response.

func (BackendSetHealthCheckerOutput) Retries 

func (o BackendSetHealthCheckerOutput) Retries() pulumi.IntPtrOutput

(Updatable) The number of retries to attempt before a backend server is considered "unhealthy". This number also applies when recovering a server to the "healthy" state. The default value is 3. Example: `3`

func (BackendSetHealthCheckerOutput) ReturnCode 

func (o BackendSetHealthCheckerOutput) ReturnCode() pulumi.IntPtrOutput

(Updatable) The status code a healthy backend server should return. If you configure the health check policy to use the HTTP protocol, then you can use common HTTP status codes such as "200". Example: `200`

func (BackendSetHealthCheckerOutput) TimeoutInMillis 

func (o BackendSetHealthCheckerOutput) TimeoutInMillis() pulumi.IntPtrOutput

(Updatable) The maximum time, in milliseconds, to wait for a reply to a health check. A health check is successful only if a reply returns within this timeout period. The default value is 3000 (3 seconds). Example: `3000`

func (BackendSetHealthCheckerOutput) ToBackendSetHealthCheckerOutput 

func (o BackendSetHealthCheckerOutput) ToBackendSetHealthCheckerOutput() BackendSetHealthCheckerOutput

func (BackendSetHealthCheckerOutput) ToBackendSetHealthCheckerOutputWithContext 

func (o BackendSetHealthCheckerOutput) ToBackendSetHealthCheckerOutputWithContext(ctx context.Context) BackendSetHealthCheckerOutput

func (BackendSetHealthCheckerOutput) ToBackendSetHealthCheckerPtrOutput 

func (o BackendSetHealthCheckerOutput) ToBackendSetHealthCheckerPtrOutput() BackendSetHealthCheckerPtrOutput

func (BackendSetHealthCheckerOutput) ToBackendSetHealthCheckerPtrOutputWithContext 

func (o BackendSetHealthCheckerOutput) ToBackendSetHealthCheckerPtrOutputWithContext(ctx context.Context) BackendSetHealthCheckerPtrOutput

func (BackendSetHealthCheckerOutput) UrlPath 

func (o BackendSetHealthCheckerOutput) UrlPath() pulumi.StringPtrOutput

(Updatable) The path against which to run the health check. Example: `/healthcheck`

type BackendSetHealthCheckerPtrInput 

type BackendSetHealthCheckerPtrInput interface {
	pulumi.Input

	ToBackendSetHealthCheckerPtrOutput() BackendSetHealthCheckerPtrOutput
	ToBackendSetHealthCheckerPtrOutputWithContext(context.Context) BackendSetHealthCheckerPtrOutput
}

BackendSetHealthCheckerPtrInput is an input type that accepts BackendSetHealthCheckerArgs, BackendSetHealthCheckerPtr and BackendSetHealthCheckerPtrOutput values. You can construct a concrete instance of `BackendSetHealthCheckerPtrInput` via: 

        BackendSetHealthCheckerArgs{...}

or:

        nil

func BackendSetHealthCheckerPtr 

func BackendSetHealthCheckerPtr(v *BackendSetHealthCheckerArgs) BackendSetHealthCheckerPtrInput

type BackendSetHealthCheckerPtrOutput 

type BackendSetHealthCheckerPtrOutput struct{ *pulumi.OutputState }

func (BackendSetHealthCheckerPtrOutput) Dns 

func (o BackendSetHealthCheckerPtrOutput) Dns() BackendSetHealthCheckerDnsPtrOutput

(Updatable) DNS healthcheck configurations.

func (BackendSetHealthCheckerPtrOutput) Elem 

func (o BackendSetHealthCheckerPtrOutput) Elem() BackendSetHealthCheckerOutput

func (BackendSetHealthCheckerPtrOutput) ElementType 

func (BackendSetHealthCheckerPtrOutput) ElementType() reflect.Type

func (BackendSetHealthCheckerPtrOutput) IntervalInMillis 

func (o BackendSetHealthCheckerPtrOutput) IntervalInMillis() pulumi.IntPtrOutput

(Updatable) The interval between health checks, in milliseconds. The default value is 10000 (10 seconds). Example: `10000`

func (BackendSetHealthCheckerPtrOutput) Port 

func (o BackendSetHealthCheckerPtrOutput) Port() pulumi.IntPtrOutput

(Updatable) The backend server port against which to run the health check. If the port is not specified, then the network load balancer uses the port information from the `Backend` object. The port must be specified if the backend port is 0. Example: `8080`

func (BackendSetHealthCheckerPtrOutput) Protocol 

func (o BackendSetHealthCheckerPtrOutput) Protocol() pulumi.StringPtrOutput

(Updatable) The protocol the health check must use; either HTTP, HTTPS, UDP, TCP or DNS. Example: `HTTP`

func (BackendSetHealthCheckerPtrOutput) RequestData 

func (o BackendSetHealthCheckerPtrOutput) RequestData() pulumi.StringPtrOutput

(Updatable) Base64 encoded pattern to be sent as UDP or TCP health check probe.

func (BackendSetHealthCheckerPtrOutput) ResponseBodyRegex 

func (o BackendSetHealthCheckerPtrOutput) ResponseBodyRegex() pulumi.StringPtrOutput

(Updatable) A regular expression for parsing the response body from the backend server. Example: `^((?!false).|\s)*$`

func (BackendSetHealthCheckerPtrOutput) ResponseData 

func (o BackendSetHealthCheckerPtrOutput) ResponseData() pulumi.StringPtrOutput

(Updatable) Base64 encoded pattern to be validated as UDP or TCP health check probe response.

func (BackendSetHealthCheckerPtrOutput) Retries 

func (o BackendSetHealthCheckerPtrOutput) Retries() pulumi.IntPtrOutput

(Updatable) The number of retries to attempt before a backend server is considered "unhealthy". This number also applies when recovering a server to the "healthy" state. The default value is 3. Example: `3`

func (BackendSetHealthCheckerPtrOutput) ReturnCode 

func (o BackendSetHealthCheckerPtrOutput) ReturnCode() pulumi.IntPtrOutput

(Updatable) The status code a healthy backend server should return. If you configure the health check policy to use the HTTP protocol, then you can use common HTTP status codes such as "200". Example: `200`

func (BackendSetHealthCheckerPtrOutput) TimeoutInMillis 

func (o BackendSetHealthCheckerPtrOutput) TimeoutInMillis() pulumi.IntPtrOutput

(Updatable) The maximum time, in milliseconds, to wait for a reply to a health check. A health check is successful only if a reply returns within this timeout period. The default value is 3000 (3 seconds). Example: `3000`

func (BackendSetHealthCheckerPtrOutput) ToBackendSetHealthCheckerPtrOutput 

func (o BackendSetHealthCheckerPtrOutput) ToBackendSetHealthCheckerPtrOutput() BackendSetHealthCheckerPtrOutput

func (BackendSetHealthCheckerPtrOutput) ToBackendSetHealthCheckerPtrOutputWithContext 

func (o BackendSetHealthCheckerPtrOutput) ToBackendSetHealthCheckerPtrOutputWithContext(ctx context.Context) BackendSetHealthCheckerPtrOutput

func (BackendSetHealthCheckerPtrOutput) UrlPath 

func (o BackendSetHealthCheckerPtrOutput) UrlPath() pulumi.StringPtrOutput

(Updatable) The path against which to run the health check. Example: `/healthcheck`

type BackendSetInput 

type BackendSetInput interface {
	pulumi.Input

	ToBackendSetOutput() BackendSetOutput
	ToBackendSetOutputWithContext(ctx context.Context) BackendSetOutput
}

type BackendSetMap 

type BackendSetMap map[string]BackendSetInput

func (BackendSetMap) ElementType 

func (BackendSetMap) ElementType() reflect.Type

func (BackendSetMap) ToBackendSetMapOutput 

func (i BackendSetMap) ToBackendSetMapOutput() BackendSetMapOutput

func (BackendSetMap) ToBackendSetMapOutputWithContext 

func (i BackendSetMap) ToBackendSetMapOutputWithContext(ctx context.Context) BackendSetMapOutput

type BackendSetMapInput 

type BackendSetMapInput interface {
	pulumi.Input

	ToBackendSetMapOutput() BackendSetMapOutput
	ToBackendSetMapOutputWithContext(context.Context) BackendSetMapOutput
}

BackendSetMapInput is an input type that accepts BackendSetMap and BackendSetMapOutput values. You can construct a concrete instance of `BackendSetMapInput` via: 

BackendSetMap{ "key": BackendSetArgs{...} }

type BackendSetMapOutput 

type BackendSetMapOutput struct{ *pulumi.OutputState }

func (BackendSetMapOutput) ElementType 

func (BackendSetMapOutput) ElementType() reflect.Type

func (BackendSetMapOutput) MapIndex 

func (o BackendSetMapOutput) MapIndex(k pulumi.StringInput) BackendSetOutput

func (BackendSetMapOutput) ToBackendSetMapOutput 

func (o BackendSetMapOutput) ToBackendSetMapOutput() BackendSetMapOutput

func (BackendSetMapOutput) ToBackendSetMapOutputWithContext 

func (o BackendSetMapOutput) ToBackendSetMapOutputWithContext(ctx context.Context) BackendSetMapOutput

type BackendSetOutput 

type BackendSetOutput struct{ *pulumi.OutputState }

func (BackendSetOutput) Backends 

func (o BackendSetOutput) Backends() BackendSetBackendArrayOutput

(Updatable) An array of backends to be associated with the backend set.

func (BackendSetOutput) ElementType 

func (BackendSetOutput) ElementType() reflect.Type

func (BackendSetOutput) HealthChecker 

func (o BackendSetOutput) HealthChecker() BackendSetHealthCheckerOutput

(Updatable) The health check policy configuration. For more information, see [Editing Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/Balance/Tasks/editinghealthcheck.htm).

func (BackendSetOutput) IpVersion 

func (o BackendSetOutput) IpVersion() pulumi.StringOutput

(Updatable) IP version associated with the backend set.

func (BackendSetOutput) IsFailOpen 

func (o BackendSetOutput) IsFailOpen() pulumi.BoolOutput

(Updatable) If enabled, the network load balancer will continue to distribute traffic in the configured distribution in the event all backends are unhealthy. The value is false by default.

func (BackendSetOutput) IsInstantFailoverEnabled 

func (o BackendSetOutput) IsInstantFailoverEnabled() pulumi.BoolOutput

(Updatable) If enabled existing connections will be forwarded to an alternative healthy backend as soon as current backend becomes unhealthy.

func (BackendSetOutput) IsPreserveSource 

func (o BackendSetOutput) IsPreserveSource() pulumi.BoolOutput

(Updatable) If this parameter is enabled, then the network load balancer preserves the source IP of the packet when it is forwarded to backends. Backends see the original source IP. If the isPreserveSourceDestination parameter is enabled for the network load balancer resource, then this parameter cannot be disabled. The value is true by default.

func (BackendSetOutput) Name 

func (o BackendSetOutput) Name() pulumi.StringOutput

A user-friendly name for the backend set that must be unique and cannot be changed.

Valid backend set names include only alphanumeric characters, dashes, and underscores. Backend set names cannot contain spaces. Avoid entering confidential information.

Example: `exampleBackendSet`

func (BackendSetOutput) NetworkLoadBalancerId 

func (o BackendSetOutput) NetworkLoadBalancerId() pulumi.StringOutput

The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.

func (BackendSetOutput) Policy 

func (o BackendSetOutput) Policy() pulumi.StringOutput

(Updatable) The network load balancer policy for the backend set. Example: `FIVE_TUPLE“

** IMPORTANT ** Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values

func (BackendSetOutput) ToBackendSetOutput 

func (o BackendSetOutput) ToBackendSetOutput() BackendSetOutput

func (BackendSetOutput) ToBackendSetOutputWithContext 

func (o BackendSetOutput) ToBackendSetOutputWithContext(ctx context.Context) BackendSetOutput

type BackendSetState 

type BackendSetState struct {
	// (Updatable) An array of backends to be associated with the backend set.
	Backends BackendSetBackendArrayInput
	// (Updatable) The health check policy configuration. For more information, see [Editing Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/Balance/Tasks/editinghealthcheck.htm).
	HealthChecker BackendSetHealthCheckerPtrInput
	// (Updatable) IP version associated with the backend set.
	IpVersion pulumi.StringPtrInput
	// (Updatable) If enabled, the network load balancer will continue to distribute traffic in the configured distribution in the event all backends are unhealthy. The value is false by default.
	IsFailOpen pulumi.BoolPtrInput
	// (Updatable) If enabled existing connections will be forwarded to an alternative healthy backend as soon as current backend becomes unhealthy.
	IsInstantFailoverEnabled pulumi.BoolPtrInput
	// (Updatable) If this parameter is enabled, then the network load balancer preserves the source IP of the packet when it is forwarded to backends. Backends see the original source IP. If the isPreserveSourceDestination parameter is enabled for the network load balancer resource, then this parameter cannot be disabled. The value is true by default.
	IsPreserveSource pulumi.BoolPtrInput
	// A user-friendly name for the backend set that must be unique and cannot be changed.
	//
	// Valid backend set names include only alphanumeric characters, dashes, and underscores. Backend set names cannot contain spaces. Avoid entering confidential information.
	//
	// Example: `exampleBackendSet`
	Name pulumi.StringPtrInput
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId pulumi.StringPtrInput
	// (Updatable) The network load balancer policy for the backend set.  Example: `FIVE_TUPLE“
	//
	// ** IMPORTANT **
	// Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
	Policy pulumi.StringPtrInput
}

func (BackendSetState) ElementType 

func (BackendSetState) ElementType() reflect.Type

type BackendState 

type BackendState struct {
	// The name of the backend set to which to add the backend server.  Example: `exampleBackendSet`
	BackendSetName pulumi.StringPtrInput
	// The IP address of the backend server. Example: `10.0.0.3`
	IpAddress pulumi.StringPtrInput
	// (Updatable) Whether the network load balancer should treat this server as a backup unit. If `true`, then the network load balancer forwards no ingress traffic to this backend server unless all other backend servers not marked as "isBackup" fail the health check policy.  Example: `false`
	IsBackup pulumi.BoolPtrInput
	// (Updatable) Whether the network load balancer should drain this server. Servers marked "isDrain" receive no incoming traffic.  Example: `false`
	IsDrain pulumi.BoolPtrInput
	// (Updatable) Whether the network load balancer should treat this server as offline. Offline servers receive no incoming traffic.  Example: `false`
	IsOffline pulumi.BoolPtrInput
	// Optional unique name identifying the backend within the backend set. If not specified, then one will be generated. Example: `webServer1`
	Name pulumi.StringPtrInput
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId pulumi.StringPtrInput
	// The communication port for the backend server.  Example: `8080`
	Port pulumi.IntPtrInput
	// The IP OCID/Instance OCID associated with the backend server. Example: `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>`
	TargetId pulumi.StringPtrInput
	// (Updatable) The network load balancing policy weight assigned to the server. Backend servers with a higher weight receive a larger proportion of incoming traffic. For example, a server weighted '3' receives three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/introducton.htm#Policies).  Example: `3`
	//
	// ** IMPORTANT **
	// Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
	Weight pulumi.IntPtrInput
}

func (BackendState) ElementType 

func (BackendState) ElementType() reflect.Type

type GetBackendHealthArgs 

type GetBackendHealthArgs struct {
	// The name of the backend server to retrieve health status for. If the backend was created with an explicitly specified name, that name should be used here. If the backend was created without explicitly specifying the name, but was created using ipAddress, this is specified as <ipAddress>:<port>. If the backend was created without explicitly specifying the name, but was created using targetId, this is specified as <targetId>:<port>.  Example: `10.0.0.3:8080` or `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>:8080`
	BackendName string `pulumi:"backendName"`
	// The name of the backend set associated with the backend server for which to retrieve the health status.  Example: `exampleBackendSet`
	BackendSetName string `pulumi:"backendSetName"`
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId string `pulumi:"networkLoadBalancerId"`
}

A collection of arguments for invoking getBackendHealth.

type GetBackendHealthHealthCheckResult 

type GetBackendHealthHealthCheckResult struct {
	// The result of the most recent health check.
	HealthCheckStatus string `pulumi:"healthCheckStatus"`
	// The date and time the data was retrieved, in the format defined by RFC3339.  Example: `2020-05-01T18:28:11+00:00`
	Timestamp string `pulumi:"timestamp"`
}

type GetBackendHealthHealthCheckResultArgs 

type GetBackendHealthHealthCheckResultArgs struct {
	// The result of the most recent health check.
	HealthCheckStatus pulumi.StringInput `pulumi:"healthCheckStatus"`
	// The date and time the data was retrieved, in the format defined by RFC3339.  Example: `2020-05-01T18:28:11+00:00`
	Timestamp pulumi.StringInput `pulumi:"timestamp"`
}

func (GetBackendHealthHealthCheckResultArgs) ElementType 

func (GetBackendHealthHealthCheckResultArgs) ElementType() reflect.Type

func (GetBackendHealthHealthCheckResultArgs) ToGetBackendHealthHealthCheckResultOutput 

func (i GetBackendHealthHealthCheckResultArgs) ToGetBackendHealthHealthCheckResultOutput() GetBackendHealthHealthCheckResultOutput

func (GetBackendHealthHealthCheckResultArgs) ToGetBackendHealthHealthCheckResultOutputWithContext 

func (i GetBackendHealthHealthCheckResultArgs) ToGetBackendHealthHealthCheckResultOutputWithContext(ctx context.Context) GetBackendHealthHealthCheckResultOutput

type GetBackendHealthHealthCheckResultArray 

type GetBackendHealthHealthCheckResultArray []GetBackendHealthHealthCheckResultInput

func (GetBackendHealthHealthCheckResultArray) ElementType 

func (GetBackendHealthHealthCheckResultArray) ElementType() reflect.Type

func (GetBackendHealthHealthCheckResultArray) ToGetBackendHealthHealthCheckResultArrayOutput 

func (i GetBackendHealthHealthCheckResultArray) ToGetBackendHealthHealthCheckResultArrayOutput() GetBackendHealthHealthCheckResultArrayOutput

func (GetBackendHealthHealthCheckResultArray) ToGetBackendHealthHealthCheckResultArrayOutputWithContext 

func (i GetBackendHealthHealthCheckResultArray) ToGetBackendHealthHealthCheckResultArrayOutputWithContext(ctx context.Context) GetBackendHealthHealthCheckResultArrayOutput

type GetBackendHealthHealthCheckResultArrayInput 

type GetBackendHealthHealthCheckResultArrayInput interface {
	pulumi.Input

	ToGetBackendHealthHealthCheckResultArrayOutput() GetBackendHealthHealthCheckResultArrayOutput
	ToGetBackendHealthHealthCheckResultArrayOutputWithContext(context.Context) GetBackendHealthHealthCheckResultArrayOutput
}

GetBackendHealthHealthCheckResultArrayInput is an input type that accepts GetBackendHealthHealthCheckResultArray and GetBackendHealthHealthCheckResultArrayOutput values. You can construct a concrete instance of `GetBackendHealthHealthCheckResultArrayInput` via: 

GetBackendHealthHealthCheckResultArray{ GetBackendHealthHealthCheckResultArgs{...} }

type GetBackendHealthHealthCheckResultArrayOutput 

type GetBackendHealthHealthCheckResultArrayOutput struct{ *pulumi.OutputState }

func (GetBackendHealthHealthCheckResultArrayOutput) ElementType 

func (GetBackendHealthHealthCheckResultArrayOutput) ElementType() reflect.Type

func (GetBackendHealthHealthCheckResultArrayOutput) Index 

func (o GetBackendHealthHealthCheckResultArrayOutput) Index(i pulumi.IntInput) GetBackendHealthHealthCheckResultOutput

func (GetBackendHealthHealthCheckResultArrayOutput) ToGetBackendHealthHealthCheckResultArrayOutput 

func (o GetBackendHealthHealthCheckResultArrayOutput) ToGetBackendHealthHealthCheckResultArrayOutput() GetBackendHealthHealthCheckResultArrayOutput

func (GetBackendHealthHealthCheckResultArrayOutput) ToGetBackendHealthHealthCheckResultArrayOutputWithContext 

func (o GetBackendHealthHealthCheckResultArrayOutput) ToGetBackendHealthHealthCheckResultArrayOutputWithContext(ctx context.Context) GetBackendHealthHealthCheckResultArrayOutput

type GetBackendHealthHealthCheckResultInput 

type GetBackendHealthHealthCheckResultInput interface {
	pulumi.Input

	ToGetBackendHealthHealthCheckResultOutput() GetBackendHealthHealthCheckResultOutput
	ToGetBackendHealthHealthCheckResultOutputWithContext(context.Context) GetBackendHealthHealthCheckResultOutput
}

GetBackendHealthHealthCheckResultInput is an input type that accepts GetBackendHealthHealthCheckResultArgs and GetBackendHealthHealthCheckResultOutput values. You can construct a concrete instance of `GetBackendHealthHealthCheckResultInput` via: 

GetBackendHealthHealthCheckResultArgs{...}

type GetBackendHealthHealthCheckResultOutput 

type GetBackendHealthHealthCheckResultOutput struct{ *pulumi.OutputState }

func (GetBackendHealthHealthCheckResultOutput) ElementType 

func (GetBackendHealthHealthCheckResultOutput) ElementType() reflect.Type

func (GetBackendHealthHealthCheckResultOutput) HealthCheckStatus 

func (o GetBackendHealthHealthCheckResultOutput) HealthCheckStatus() pulumi.StringOutput

The result of the most recent health check.

func (GetBackendHealthHealthCheckResultOutput) Timestamp 

func (o GetBackendHealthHealthCheckResultOutput) Timestamp() pulumi.StringOutput

The date and time the data was retrieved, in the format defined by RFC3339. Example: `2020-05-01T18:28:11+00:00`

func (GetBackendHealthHealthCheckResultOutput) ToGetBackendHealthHealthCheckResultOutput 

func (o GetBackendHealthHealthCheckResultOutput) ToGetBackendHealthHealthCheckResultOutput() GetBackendHealthHealthCheckResultOutput

func (GetBackendHealthHealthCheckResultOutput) ToGetBackendHealthHealthCheckResultOutputWithContext 

func (o GetBackendHealthHealthCheckResultOutput) ToGetBackendHealthHealthCheckResultOutputWithContext(ctx context.Context) GetBackendHealthHealthCheckResultOutput

type GetBackendHealthOutputArgs 

type GetBackendHealthOutputArgs struct {
	// The name of the backend server to retrieve health status for. If the backend was created with an explicitly specified name, that name should be used here. If the backend was created without explicitly specifying the name, but was created using ipAddress, this is specified as <ipAddress>:<port>. If the backend was created without explicitly specifying the name, but was created using targetId, this is specified as <targetId>:<port>.  Example: `10.0.0.3:8080` or `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>:8080`
	BackendName pulumi.StringInput `pulumi:"backendName"`
	// The name of the backend set associated with the backend server for which to retrieve the health status.  Example: `exampleBackendSet`
	BackendSetName pulumi.StringInput `pulumi:"backendSetName"`
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId pulumi.StringInput `pulumi:"networkLoadBalancerId"`
}

A collection of arguments for invoking getBackendHealth.

func (GetBackendHealthOutputArgs) ElementType 

func (GetBackendHealthOutputArgs) ElementType() reflect.Type

type GetBackendHealthResult 

type GetBackendHealthResult struct {
	BackendName    string `pulumi:"backendName"`
	BackendSetName string `pulumi:"backendSetName"`
	// A list of the most recent health check results returned for the specified backend server.
	HealthCheckResults []GetBackendHealthHealthCheckResult `pulumi:"healthCheckResults"`
	// The provider-assigned unique ID for this managed resource.
	Id                    string `pulumi:"id"`
	NetworkLoadBalancerId string `pulumi:"networkLoadBalancerId"`
	// The general health status of the specified backend server.
	// *   **OK:**  All health check probes return `OK`
	// *   **WARNING:** At least one of the health check probes does not return `OK`
	// *   **CRITICAL:** None of the health check probes return `OK`. *
	// *   **UNKNOWN:** One of the health checks probes return `UNKNOWN`,
	// *   or the system is unable to retrieve metrics at this time.
	Status string `pulumi:"status"`
}

A collection of values returned by getBackendHealth.

func GetBackendHealth 

func GetBackendHealth(ctx *pulumi.Context, args *GetBackendHealthArgs, opts ...pulumi.InvokeOption) (*GetBackendHealthResult, error)

This data source provides details about a specific Backend Health resource in Oracle Cloud Infrastructure Network Load Balancer service.

Retrieves the current health status of the specified backend server.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-oci/sdk/v2/go/oci/NetworkLoadBalancer"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := NetworkLoadBalancer.GetBackendHealth(ctx, &networkloadbalancer.GetBackendHealthArgs{
			BackendName:           testBackend.Name,
			BackendSetName:        testBackendSet.Name,
			NetworkLoadBalancerId: testNetworkLoadBalancer.Id,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type GetBackendHealthResultOutput 

type GetBackendHealthResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getBackendHealth.

func GetBackendHealthOutput 

func GetBackendHealthOutput(ctx *pulumi.Context, args GetBackendHealthOutputArgs, opts ...pulumi.InvokeOption) GetBackendHealthResultOutput

func (GetBackendHealthResultOutput) BackendName 

func (o GetBackendHealthResultOutput) BackendName() pulumi.StringOutput

func (GetBackendHealthResultOutput) BackendSetName 

func (o GetBackendHealthResultOutput) BackendSetName() pulumi.StringOutput

func (GetBackendHealthResultOutput) ElementType 

func (GetBackendHealthResultOutput) ElementType() reflect.Type

func (GetBackendHealthResultOutput) HealthCheckResults 

func (o GetBackendHealthResultOutput) HealthCheckResults() GetBackendHealthHealthCheckResultArrayOutput

A list of the most recent health check results returned for the specified backend server.

func (GetBackendHealthResultOutput) Id 

func (o GetBackendHealthResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (GetBackendHealthResultOutput) NetworkLoadBalancerId 

func (o GetBackendHealthResultOutput) NetworkLoadBalancerId() pulumi.StringOutput

func (GetBackendHealthResultOutput) Status 

func (o GetBackendHealthResultOutput) Status() pulumi.StringOutput

The general health status of the specified backend server. * **OK:** All health check probes return `OK` * **WARNING:** At least one of the health check probes does not return `OK` * **CRITICAL:** None of the health check probes return `OK`. * * **UNKNOWN:** One of the health checks probes return `UNKNOWN`, * or the system is unable to retrieve metrics at this time.

func (GetBackendHealthResultOutput) ToGetBackendHealthResultOutput 

func (o GetBackendHealthResultOutput) ToGetBackendHealthResultOutput() GetBackendHealthResultOutput

func (GetBackendHealthResultOutput) ToGetBackendHealthResultOutputWithContext 

func (o GetBackendHealthResultOutput) ToGetBackendHealthResultOutputWithContext(ctx context.Context) GetBackendHealthResultOutput

type GetBackendSetBackend 

type GetBackendSetBackend struct {
	// The IP address of the backend server. Example: `10.0.0.3`
	IpAddress string `pulumi:"ipAddress"`
	// Whether the network load balancer should treat this server as a backup unit. If `true`, then the network load balancer forwards no ingress traffic to this backend server unless all other backend servers not marked as "isBackup" fail the health check policy.  Example: `false`
	IsBackup bool `pulumi:"isBackup"`
	// Whether the network load balancer should drain this server. Servers marked "isDrain" receive no incoming traffic.  Example: `false`
	IsDrain bool `pulumi:"isDrain"`
	// Whether the network load balancer should treat this server as offline. Offline servers receive no incoming traffic.  Example: `false`
	IsOffline bool `pulumi:"isOffline"`
	// A user-friendly name for the backend set that must be unique and cannot be changed.
	Name string `pulumi:"name"`
	// The backend server port against which to run the health check. If the port is not specified, then the network load balancer uses the port information from the `Backend` object. The port must be specified if the backend port is 0.  Example: `8080`
	Port int `pulumi:"port"`
	// The IP OCID/Instance OCID associated with the backend server. Example: `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>`
	TargetId string `pulumi:"targetId"`
	// The network load balancing policy weight assigned to the server. Backend servers with a higher weight receive a larger proportion of incoming traffic. For example, a server weighted '3' receives three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/lbpolicies.htm).  Example: `3`
	Weight int `pulumi:"weight"`
}

type GetBackendSetBackendArgs 

type GetBackendSetBackendArgs struct {
	// The IP address of the backend server. Example: `10.0.0.3`
	IpAddress pulumi.StringInput `pulumi:"ipAddress"`
	// Whether the network load balancer should treat this server as a backup unit. If `true`, then the network load balancer forwards no ingress traffic to this backend server unless all other backend servers not marked as "isBackup" fail the health check policy.  Example: `false`
	IsBackup pulumi.BoolInput `pulumi:"isBackup"`
	// Whether the network load balancer should drain this server. Servers marked "isDrain" receive no incoming traffic.  Example: `false`
	IsDrain pulumi.BoolInput `pulumi:"isDrain"`
	// Whether the network load balancer should treat this server as offline. Offline servers receive no incoming traffic.  Example: `false`
	IsOffline pulumi.BoolInput `pulumi:"isOffline"`
	// A user-friendly name for the backend set that must be unique and cannot be changed.
	Name pulumi.StringInput `pulumi:"name"`
	// The backend server port against which to run the health check. If the port is not specified, then the network load balancer uses the port information from the `Backend` object. The port must be specified if the backend port is 0.  Example: `8080`
	Port pulumi.IntInput `pulumi:"port"`
	// The IP OCID/Instance OCID associated with the backend server. Example: `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>`
	TargetId pulumi.StringInput `pulumi:"targetId"`
	// The network load balancing policy weight assigned to the server. Backend servers with a higher weight receive a larger proportion of incoming traffic. For example, a server weighted '3' receives three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/lbpolicies.htm).  Example: `3`
	Weight pulumi.IntInput `pulumi:"weight"`
}

func (GetBackendSetBackendArgs) ElementType 

func (GetBackendSetBackendArgs) ElementType() reflect.Type

func (GetBackendSetBackendArgs) ToGetBackendSetBackendOutput 

func (i GetBackendSetBackendArgs) ToGetBackendSetBackendOutput() GetBackendSetBackendOutput

func (GetBackendSetBackendArgs) ToGetBackendSetBackendOutputWithContext 

func (i GetBackendSetBackendArgs) ToGetBackendSetBackendOutputWithContext(ctx context.Context) GetBackendSetBackendOutput

type GetBackendSetBackendArray 

type GetBackendSetBackendArray []GetBackendSetBackendInput

func (GetBackendSetBackendArray) ElementType 

func (GetBackendSetBackendArray) ElementType() reflect.Type

func (GetBackendSetBackendArray) ToGetBackendSetBackendArrayOutput 

func (i GetBackendSetBackendArray) ToGetBackendSetBackendArrayOutput() GetBackendSetBackendArrayOutput

func (GetBackendSetBackendArray) ToGetBackendSetBackendArrayOutputWithContext 

func (i GetBackendSetBackendArray) ToGetBackendSetBackendArrayOutputWithContext(ctx context.Context) GetBackendSetBackendArrayOutput

type GetBackendSetBackendArrayInput 

type GetBackendSetBackendArrayInput interface {
	pulumi.Input

	ToGetBackendSetBackendArrayOutput() GetBackendSetBackendArrayOutput
	ToGetBackendSetBackendArrayOutputWithContext(context.Context) GetBackendSetBackendArrayOutput
}

GetBackendSetBackendArrayInput is an input type that accepts GetBackendSetBackendArray and GetBackendSetBackendArrayOutput values. You can construct a concrete instance of `GetBackendSetBackendArrayInput` via: 

GetBackendSetBackendArray{ GetBackendSetBackendArgs{...} }

type GetBackendSetBackendArrayOutput 

type GetBackendSetBackendArrayOutput struct{ *pulumi.OutputState }

func (GetBackendSetBackendArrayOutput) ElementType 

func (GetBackendSetBackendArrayOutput) ElementType() reflect.Type

func (GetBackendSetBackendArrayOutput) Index 

func (o GetBackendSetBackendArrayOutput) Index(i pulumi.IntInput) GetBackendSetBackendOutput

func (GetBackendSetBackendArrayOutput) ToGetBackendSetBackendArrayOutput 

func (o GetBackendSetBackendArrayOutput) ToGetBackendSetBackendArrayOutput() GetBackendSetBackendArrayOutput

func (GetBackendSetBackendArrayOutput) ToGetBackendSetBackendArrayOutputWithContext 

func (o GetBackendSetBackendArrayOutput) ToGetBackendSetBackendArrayOutputWithContext(ctx context.Context) GetBackendSetBackendArrayOutput

type GetBackendSetBackendInput 

type GetBackendSetBackendInput interface {
	pulumi.Input

	ToGetBackendSetBackendOutput() GetBackendSetBackendOutput
	ToGetBackendSetBackendOutputWithContext(context.Context) GetBackendSetBackendOutput
}

GetBackendSetBackendInput is an input type that accepts GetBackendSetBackendArgs and GetBackendSetBackendOutput values. You can construct a concrete instance of `GetBackendSetBackendInput` via: 

GetBackendSetBackendArgs{...}

type GetBackendSetBackendOutput 

type GetBackendSetBackendOutput struct{ *pulumi.OutputState }

func (GetBackendSetBackendOutput) ElementType 

func (GetBackendSetBackendOutput) ElementType() reflect.Type

func (GetBackendSetBackendOutput) IpAddress 

func (o GetBackendSetBackendOutput) IpAddress() pulumi.StringOutput

The IP address of the backend server. Example: `10.0.0.3`

func (GetBackendSetBackendOutput) IsBackup 

func (o GetBackendSetBackendOutput) IsBackup() pulumi.BoolOutput

Whether the network load balancer should treat this server as a backup unit. If `true`, then the network load balancer forwards no ingress traffic to this backend server unless all other backend servers not marked as "isBackup" fail the health check policy. Example: `false`

func (GetBackendSetBackendOutput) IsDrain 

func (o GetBackendSetBackendOutput) IsDrain() pulumi.BoolOutput

Whether the network load balancer should drain this server. Servers marked "isDrain" receive no incoming traffic. Example: `false`

func (GetBackendSetBackendOutput) IsOffline 

func (o GetBackendSetBackendOutput) IsOffline() pulumi.BoolOutput

Whether the network load balancer should treat this server as offline. Offline servers receive no incoming traffic. Example: `false`

func (GetBackendSetBackendOutput) Name 

func (o GetBackendSetBackendOutput) Name() pulumi.StringOutput

A user-friendly name for the backend set that must be unique and cannot be changed.

func (GetBackendSetBackendOutput) Port 

func (o GetBackendSetBackendOutput) Port() pulumi.IntOutput

The backend server port against which to run the health check. If the port is not specified, then the network load balancer uses the port information from the `Backend` object. The port must be specified if the backend port is 0. Example: `8080`

func (GetBackendSetBackendOutput) TargetId 

func (o GetBackendSetBackendOutput) TargetId() pulumi.StringOutput

The IP OCID/Instance OCID associated with the backend server. Example: `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>`

func (GetBackendSetBackendOutput) ToGetBackendSetBackendOutput 

func (o GetBackendSetBackendOutput) ToGetBackendSetBackendOutput() GetBackendSetBackendOutput

func (GetBackendSetBackendOutput) ToGetBackendSetBackendOutputWithContext 

func (o GetBackendSetBackendOutput) ToGetBackendSetBackendOutputWithContext(ctx context.Context) GetBackendSetBackendOutput

func (GetBackendSetBackendOutput) Weight 

func (o GetBackendSetBackendOutput) Weight() pulumi.IntOutput

The network load balancing policy weight assigned to the server. Backend servers with a higher weight receive a larger proportion of incoming traffic. For example, a server weighted '3' receives three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/lbpolicies.htm). Example: `3`

type GetBackendSetHealthArgs 

type GetBackendSetHealthArgs struct {
	BackendSetName        string `pulumi:"backendSetName"`
	NetworkLoadBalancerId string `pulumi:"networkLoadBalancerId"`
}

A collection of arguments for invoking getBackendSetHealth.

type GetBackendSetHealthChecker 

type GetBackendSetHealthChecker struct {
	// DNS healthcheck configurations.
	Dns []GetBackendSetHealthCheckerDn `pulumi:"dns"`
	// The interval between health checks, in milliseconds. The default value is 10000 (10 seconds).  Example: `10000`
	IntervalInMillis int `pulumi:"intervalInMillis"`
	// The backend server port against which to run the health check. If the port is not specified, then the network load balancer uses the port information from the `Backend` object. The port must be specified if the backend port is 0.  Example: `8080`
	Port int `pulumi:"port"`
	// The protocol the health check must use; either HTTP, HTTPS, UDP, TCP or DNS.  Example: `HTTP`
	Protocol string `pulumi:"protocol"`
	// Base64 encoded pattern to be sent as UDP or TCP health check probe.
	RequestData string `pulumi:"requestData"`
	// A regular expression for parsing the response body from the backend server.  Example: `^((?!false).|\s)*$`
	ResponseBodyRegex string `pulumi:"responseBodyRegex"`
	// Base64 encoded pattern to be validated as UDP or TCP health check probe response.
	ResponseData string `pulumi:"responseData"`
	// The number of retries to attempt before a backend server is considered "unhealthy". This number also applies when recovering a server to the "healthy" state. The default value is 3.  Example: `3`
	Retries int `pulumi:"retries"`
	// The status code a healthy backend server should return. If you configure the health check policy to use the HTTP protocol, then you can use common HTTP status codes such as "200".  Example: `200`
	ReturnCode int `pulumi:"returnCode"`
	// The maximum time, in milliseconds, to wait for a reply to a health check. A health check is successful only if a reply returns within this timeout period. The default value is 3000 (3 seconds).  Example: `3000`
	TimeoutInMillis int `pulumi:"timeoutInMillis"`
	// The path against which to run the health check.  Example: `/healthcheck`
	UrlPath string `pulumi:"urlPath"`
}

type GetBackendSetHealthCheckerArgs 

type GetBackendSetHealthCheckerArgs struct {
	// DNS healthcheck configurations.
	Dns GetBackendSetHealthCheckerDnArrayInput `pulumi:"dns"`
	// The interval between health checks, in milliseconds. The default value is 10000 (10 seconds).  Example: `10000`
	IntervalInMillis pulumi.IntInput `pulumi:"intervalInMillis"`
	// The backend server port against which to run the health check. If the port is not specified, then the network load balancer uses the port information from the `Backend` object. The port must be specified if the backend port is 0.  Example: `8080`
	Port pulumi.IntInput `pulumi:"port"`
	// The protocol the health check must use; either HTTP, HTTPS, UDP, TCP or DNS.  Example: `HTTP`
	Protocol pulumi.StringInput `pulumi:"protocol"`
	// Base64 encoded pattern to be sent as UDP or TCP health check probe.
	RequestData pulumi.StringInput `pulumi:"requestData"`
	// A regular expression for parsing the response body from the backend server.  Example: `^((?!false).|\s)*$`
	ResponseBodyRegex pulumi.StringInput `pulumi:"responseBodyRegex"`
	// Base64 encoded pattern to be validated as UDP or TCP health check probe response.
	ResponseData pulumi.StringInput `pulumi:"responseData"`
	// The number of retries to attempt before a backend server is considered "unhealthy". This number also applies when recovering a server to the "healthy" state. The default value is 3.  Example: `3`
	Retries pulumi.IntInput `pulumi:"retries"`
	// The status code a healthy backend server should return. If you configure the health check policy to use the HTTP protocol, then you can use common HTTP status codes such as "200".  Example: `200`
	ReturnCode pulumi.IntInput `pulumi:"returnCode"`
	// The maximum time, in milliseconds, to wait for a reply to a health check. A health check is successful only if a reply returns within this timeout period. The default value is 3000 (3 seconds).  Example: `3000`
	TimeoutInMillis pulumi.IntInput `pulumi:"timeoutInMillis"`
	// The path against which to run the health check.  Example: `/healthcheck`
	UrlPath pulumi.StringInput `pulumi:"urlPath"`
}

func (GetBackendSetHealthCheckerArgs) ElementType 

func (GetBackendSetHealthCheckerArgs) ElementType() reflect.Type

func (GetBackendSetHealthCheckerArgs) ToGetBackendSetHealthCheckerOutput 

func (i GetBackendSetHealthCheckerArgs) ToGetBackendSetHealthCheckerOutput() GetBackendSetHealthCheckerOutput

func (GetBackendSetHealthCheckerArgs) ToGetBackendSetHealthCheckerOutputWithContext 

func (i GetBackendSetHealthCheckerArgs) ToGetBackendSetHealthCheckerOutputWithContext(ctx context.Context) GetBackendSetHealthCheckerOutput

type GetBackendSetHealthCheckerArray 

type GetBackendSetHealthCheckerArray []GetBackendSetHealthCheckerInput

func (GetBackendSetHealthCheckerArray) ElementType 

func (GetBackendSetHealthCheckerArray) ElementType() reflect.Type

func (GetBackendSetHealthCheckerArray) ToGetBackendSetHealthCheckerArrayOutput 

func (i GetBackendSetHealthCheckerArray) ToGetBackendSetHealthCheckerArrayOutput() GetBackendSetHealthCheckerArrayOutput

func (GetBackendSetHealthCheckerArray) ToGetBackendSetHealthCheckerArrayOutputWithContext 

func (i GetBackendSetHealthCheckerArray) ToGetBackendSetHealthCheckerArrayOutputWithContext(ctx context.Context) GetBackendSetHealthCheckerArrayOutput

type GetBackendSetHealthCheckerArrayInput 

type GetBackendSetHealthCheckerArrayInput interface {
	pulumi.Input

	ToGetBackendSetHealthCheckerArrayOutput() GetBackendSetHealthCheckerArrayOutput
	ToGetBackendSetHealthCheckerArrayOutputWithContext(context.Context) GetBackendSetHealthCheckerArrayOutput
}

GetBackendSetHealthCheckerArrayInput is an input type that accepts GetBackendSetHealthCheckerArray and GetBackendSetHealthCheckerArrayOutput values. You can construct a concrete instance of `GetBackendSetHealthCheckerArrayInput` via: 

GetBackendSetHealthCheckerArray{ GetBackendSetHealthCheckerArgs{...} }

type GetBackendSetHealthCheckerArrayOutput 

type GetBackendSetHealthCheckerArrayOutput struct{ *pulumi.OutputState }

func (GetBackendSetHealthCheckerArrayOutput) ElementType 

func (GetBackendSetHealthCheckerArrayOutput) ElementType() reflect.Type

func (GetBackendSetHealthCheckerArrayOutput) Index 

func (o GetBackendSetHealthCheckerArrayOutput) Index(i pulumi.IntInput) GetBackendSetHealthCheckerOutput

func (GetBackendSetHealthCheckerArrayOutput) ToGetBackendSetHealthCheckerArrayOutput 

func (o GetBackendSetHealthCheckerArrayOutput) ToGetBackendSetHealthCheckerArrayOutput() GetBackendSetHealthCheckerArrayOutput

func (GetBackendSetHealthCheckerArrayOutput) ToGetBackendSetHealthCheckerArrayOutputWithContext 

func (o GetBackendSetHealthCheckerArrayOutput) ToGetBackendSetHealthCheckerArrayOutputWithContext(ctx context.Context) GetBackendSetHealthCheckerArrayOutput

type GetBackendSetHealthCheckerDn 

type GetBackendSetHealthCheckerDn struct {
	// The absolute fully-qualified domain name to perform periodic DNS queries. If not provided, an extra dot will be added at the end of a domain name during the query.
	DomainName string `pulumi:"domainName"`
	// The class the dns health check query to use; either IN or CH.  Example: `IN`
	QueryClass string `pulumi:"queryClass"`
	// The type the dns health check query to use; A, AAAA, TXT.  Example: `A`
	QueryType string `pulumi:"queryType"`
	// An array that represents accepetable RCODE values for DNS query response. Example: ["NOERROR", "NXDOMAIN"]
	Rcodes []string `pulumi:"rcodes"`
	// DNS transport protocol; either UDP or TCP.  Example: `UDP`
	TransportProtocol string `pulumi:"transportProtocol"`
}

type GetBackendSetHealthCheckerDnArgs 

type GetBackendSetHealthCheckerDnArgs struct {
	// The absolute fully-qualified domain name to perform periodic DNS queries. If not provided, an extra dot will be added at the end of a domain name during the query.
	DomainName pulumi.StringInput `pulumi:"domainName"`
	// The class the dns health check query to use; either IN or CH.  Example: `IN`
	QueryClass pulumi.StringInput `pulumi:"queryClass"`
	// The type the dns health check query to use; A, AAAA, TXT.  Example: `A`
	QueryType pulumi.StringInput `pulumi:"queryType"`
	// An array that represents accepetable RCODE values for DNS query response. Example: ["NOERROR", "NXDOMAIN"]
	Rcodes pulumi.StringArrayInput `pulumi:"rcodes"`
	// DNS transport protocol; either UDP or TCP.  Example: `UDP`
	TransportProtocol pulumi.StringInput `pulumi:"transportProtocol"`
}

func (GetBackendSetHealthCheckerDnArgs) ElementType 

func (GetBackendSetHealthCheckerDnArgs) ElementType() reflect.Type

func (GetBackendSetHealthCheckerDnArgs) ToGetBackendSetHealthCheckerDnOutput 

func (i GetBackendSetHealthCheckerDnArgs) ToGetBackendSetHealthCheckerDnOutput() GetBackendSetHealthCheckerDnOutput

func (GetBackendSetHealthCheckerDnArgs) ToGetBackendSetHealthCheckerDnOutputWithContext 

func (i GetBackendSetHealthCheckerDnArgs) ToGetBackendSetHealthCheckerDnOutputWithContext(ctx context.Context) GetBackendSetHealthCheckerDnOutput

type GetBackendSetHealthCheckerDnArray 

type GetBackendSetHealthCheckerDnArray []GetBackendSetHealthCheckerDnInput

func (GetBackendSetHealthCheckerDnArray) ElementType 

func (GetBackendSetHealthCheckerDnArray) ElementType() reflect.Type

func (GetBackendSetHealthCheckerDnArray) ToGetBackendSetHealthCheckerDnArrayOutput 

func (i GetBackendSetHealthCheckerDnArray) ToGetBackendSetHealthCheckerDnArrayOutput() GetBackendSetHealthCheckerDnArrayOutput

func (GetBackendSetHealthCheckerDnArray) ToGetBackendSetHealthCheckerDnArrayOutputWithContext 

func (i GetBackendSetHealthCheckerDnArray) ToGetBackendSetHealthCheckerDnArrayOutputWithContext(ctx context.Context) GetBackendSetHealthCheckerDnArrayOutput

type GetBackendSetHealthCheckerDnArrayInput 

type GetBackendSetHealthCheckerDnArrayInput interface {
	pulumi.Input

	ToGetBackendSetHealthCheckerDnArrayOutput() GetBackendSetHealthCheckerDnArrayOutput
	ToGetBackendSetHealthCheckerDnArrayOutputWithContext(context.Context) GetBackendSetHealthCheckerDnArrayOutput
}

GetBackendSetHealthCheckerDnArrayInput is an input type that accepts GetBackendSetHealthCheckerDnArray and GetBackendSetHealthCheckerDnArrayOutput values. You can construct a concrete instance of `GetBackendSetHealthCheckerDnArrayInput` via: 

GetBackendSetHealthCheckerDnArray{ GetBackendSetHealthCheckerDnArgs{...} }

type GetBackendSetHealthCheckerDnArrayOutput 

type GetBackendSetHealthCheckerDnArrayOutput struct{ *pulumi.OutputState }

func (GetBackendSetHealthCheckerDnArrayOutput) ElementType 

func (GetBackendSetHealthCheckerDnArrayOutput) ElementType() reflect.Type

func (GetBackendSetHealthCheckerDnArrayOutput) Index 

func (o GetBackendSetHealthCheckerDnArrayOutput) Index(i pulumi.IntInput) GetBackendSetHealthCheckerDnOutput

func (GetBackendSetHealthCheckerDnArrayOutput) ToGetBackendSetHealthCheckerDnArrayOutput 

func (o GetBackendSetHealthCheckerDnArrayOutput) ToGetBackendSetHealthCheckerDnArrayOutput() GetBackendSetHealthCheckerDnArrayOutput

func (GetBackendSetHealthCheckerDnArrayOutput) ToGetBackendSetHealthCheckerDnArrayOutputWithContext 

func (o GetBackendSetHealthCheckerDnArrayOutput) ToGetBackendSetHealthCheckerDnArrayOutputWithContext(ctx context.Context) GetBackendSetHealthCheckerDnArrayOutput

type GetBackendSetHealthCheckerDnInput 

type GetBackendSetHealthCheckerDnInput interface {
	pulumi.Input

	ToGetBackendSetHealthCheckerDnOutput() GetBackendSetHealthCheckerDnOutput
	ToGetBackendSetHealthCheckerDnOutputWithContext(context.Context) GetBackendSetHealthCheckerDnOutput
}

GetBackendSetHealthCheckerDnInput is an input type that accepts GetBackendSetHealthCheckerDnArgs and GetBackendSetHealthCheckerDnOutput values. You can construct a concrete instance of `GetBackendSetHealthCheckerDnInput` via: 

GetBackendSetHealthCheckerDnArgs{...}

type GetBackendSetHealthCheckerDnOutput 

type GetBackendSetHealthCheckerDnOutput struct{ *pulumi.OutputState }

func (GetBackendSetHealthCheckerDnOutput) DomainName 

func (o GetBackendSetHealthCheckerDnOutput) DomainName() pulumi.StringOutput

The absolute fully-qualified domain name to perform periodic DNS queries. If not provided, an extra dot will be added at the end of a domain name during the query.

func (GetBackendSetHealthCheckerDnOutput) ElementType 

func (GetBackendSetHealthCheckerDnOutput) ElementType() reflect.Type

func (GetBackendSetHealthCheckerDnOutput) QueryClass 

func (o GetBackendSetHealthCheckerDnOutput) QueryClass() pulumi.StringOutput

The class the dns health check query to use; either IN or CH. Example: `IN`

func (GetBackendSetHealthCheckerDnOutput) QueryType 

func (o GetBackendSetHealthCheckerDnOutput) QueryType() pulumi.StringOutput

The type the dns health check query to use; A, AAAA, TXT. Example: `A`

func (GetBackendSetHealthCheckerDnOutput) Rcodes 

func (o GetBackendSetHealthCheckerDnOutput) Rcodes() pulumi.StringArrayOutput

An array that represents accepetable RCODE values for DNS query response. Example: ["NOERROR", "NXDOMAIN"]

func (GetBackendSetHealthCheckerDnOutput) ToGetBackendSetHealthCheckerDnOutput 

func (o GetBackendSetHealthCheckerDnOutput) ToGetBackendSetHealthCheckerDnOutput() GetBackendSetHealthCheckerDnOutput

func (GetBackendSetHealthCheckerDnOutput) ToGetBackendSetHealthCheckerDnOutputWithContext 

func (o GetBackendSetHealthCheckerDnOutput) ToGetBackendSetHealthCheckerDnOutputWithContext(ctx context.Context) GetBackendSetHealthCheckerDnOutput

func (GetBackendSetHealthCheckerDnOutput) TransportProtocol 

func (o GetBackendSetHealthCheckerDnOutput) TransportProtocol() pulumi.StringOutput

DNS transport protocol; either UDP or TCP. Example: `UDP`

type GetBackendSetHealthCheckerInput 

type GetBackendSetHealthCheckerInput interface {
	pulumi.Input

	ToGetBackendSetHealthCheckerOutput() GetBackendSetHealthCheckerOutput
	ToGetBackendSetHealthCheckerOutputWithContext(context.Context) GetBackendSetHealthCheckerOutput
}

GetBackendSetHealthCheckerInput is an input type that accepts GetBackendSetHealthCheckerArgs and GetBackendSetHealthCheckerOutput values. You can construct a concrete instance of `GetBackendSetHealthCheckerInput` via: 

GetBackendSetHealthCheckerArgs{...}

type GetBackendSetHealthCheckerOutput 

type GetBackendSetHealthCheckerOutput struct{ *pulumi.OutputState }

func (GetBackendSetHealthCheckerOutput) Dns 

func (o GetBackendSetHealthCheckerOutput) Dns() GetBackendSetHealthCheckerDnArrayOutput

DNS healthcheck configurations.

func (GetBackendSetHealthCheckerOutput) ElementType 

func (GetBackendSetHealthCheckerOutput) ElementType() reflect.Type

func (GetBackendSetHealthCheckerOutput) IntervalInMillis 

func (o GetBackendSetHealthCheckerOutput) IntervalInMillis() pulumi.IntOutput

The interval between health checks, in milliseconds. The default value is 10000 (10 seconds). Example: `10000`

func (GetBackendSetHealthCheckerOutput) Port 

func (o GetBackendSetHealthCheckerOutput) Port() pulumi.IntOutput

The backend server port against which to run the health check. If the port is not specified, then the network load balancer uses the port information from the `Backend` object. The port must be specified if the backend port is 0. Example: `8080`

func (GetBackendSetHealthCheckerOutput) Protocol 

func (o GetBackendSetHealthCheckerOutput) Protocol() pulumi.StringOutput

The protocol the health check must use; either HTTP, HTTPS, UDP, TCP or DNS. Example: `HTTP`

func (GetBackendSetHealthCheckerOutput) RequestData 

func (o GetBackendSetHealthCheckerOutput) RequestData() pulumi.StringOutput

Base64 encoded pattern to be sent as UDP or TCP health check probe.

func (GetBackendSetHealthCheckerOutput) ResponseBodyRegex 

func (o GetBackendSetHealthCheckerOutput) ResponseBodyRegex() pulumi.StringOutput

A regular expression for parsing the response body from the backend server. Example: `^((?!false).|\s)*$`

func (GetBackendSetHealthCheckerOutput) ResponseData 

func (o GetBackendSetHealthCheckerOutput) ResponseData() pulumi.StringOutput

Base64 encoded pattern to be validated as UDP or TCP health check probe response.

func (GetBackendSetHealthCheckerOutput) Retries 

func (o GetBackendSetHealthCheckerOutput) Retries() pulumi.IntOutput

The number of retries to attempt before a backend server is considered "unhealthy". This number also applies when recovering a server to the "healthy" state. The default value is 3. Example: `3`

func (GetBackendSetHealthCheckerOutput) ReturnCode 

func (o GetBackendSetHealthCheckerOutput) ReturnCode() pulumi.IntOutput

The status code a healthy backend server should return. If you configure the health check policy to use the HTTP protocol, then you can use common HTTP status codes such as "200". Example: `200`

func (GetBackendSetHealthCheckerOutput) TimeoutInMillis 

func (o GetBackendSetHealthCheckerOutput) TimeoutInMillis() pulumi.IntOutput

The maximum time, in milliseconds, to wait for a reply to a health check. A health check is successful only if a reply returns within this timeout period. The default value is 3000 (3 seconds). Example: `3000`

func (GetBackendSetHealthCheckerOutput) ToGetBackendSetHealthCheckerOutput 

func (o GetBackendSetHealthCheckerOutput) ToGetBackendSetHealthCheckerOutput() GetBackendSetHealthCheckerOutput

func (GetBackendSetHealthCheckerOutput) ToGetBackendSetHealthCheckerOutputWithContext 

func (o GetBackendSetHealthCheckerOutput) ToGetBackendSetHealthCheckerOutputWithContext(ctx context.Context) GetBackendSetHealthCheckerOutput

func (GetBackendSetHealthCheckerOutput) UrlPath 

func (o GetBackendSetHealthCheckerOutput) UrlPath() pulumi.StringOutput

The path against which to run the health check. Example: `/healthcheck`

type GetBackendSetHealthOutputArgs 

type GetBackendSetHealthOutputArgs struct {
	BackendSetName        pulumi.StringInput `pulumi:"backendSetName"`
	NetworkLoadBalancerId pulumi.StringInput `pulumi:"networkLoadBalancerId"`
}

A collection of arguments for invoking getBackendSetHealth.

func (GetBackendSetHealthOutputArgs) ElementType 

func (GetBackendSetHealthOutputArgs) ElementType() reflect.Type

type GetBackendSetHealthResult 

type GetBackendSetHealthResult struct {
	BackendSetName            string   `pulumi:"backendSetName"`
	CriticalStateBackendNames []string `pulumi:"criticalStateBackendNames"`
	// The provider-assigned unique ID for this managed resource.
	Id                       string   `pulumi:"id"`
	NetworkLoadBalancerId    string   `pulumi:"networkLoadBalancerId"`
	Status                   string   `pulumi:"status"`
	TotalBackendCount        int      `pulumi:"totalBackendCount"`
	UnknownStateBackendNames []string `pulumi:"unknownStateBackendNames"`
	WarningStateBackendNames []string `pulumi:"warningStateBackendNames"`
}

A collection of values returned by getBackendSetHealth.

func GetBackendSetHealth 

func GetBackendSetHealth(ctx *pulumi.Context, args *GetBackendSetHealthArgs, opts ...pulumi.InvokeOption) (*GetBackendSetHealthResult, error)

type GetBackendSetHealthResultOutput 

type GetBackendSetHealthResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getBackendSetHealth.

func GetBackendSetHealthOutput 

func GetBackendSetHealthOutput(ctx *pulumi.Context, args GetBackendSetHealthOutputArgs, opts ...pulumi.InvokeOption) GetBackendSetHealthResultOutput

func (GetBackendSetHealthResultOutput) BackendSetName 

func (o GetBackendSetHealthResultOutput) BackendSetName() pulumi.StringOutput

func (GetBackendSetHealthResultOutput) CriticalStateBackendNames 

func (o GetBackendSetHealthResultOutput) CriticalStateBackendNames() pulumi.StringArrayOutput

func (GetBackendSetHealthResultOutput) ElementType 

func (GetBackendSetHealthResultOutput) ElementType() reflect.Type

func (GetBackendSetHealthResultOutput) Id 

func (o GetBackendSetHealthResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (GetBackendSetHealthResultOutput) NetworkLoadBalancerId 

func (o GetBackendSetHealthResultOutput) NetworkLoadBalancerId() pulumi.StringOutput

func (GetBackendSetHealthResultOutput) Status 

func (o GetBackendSetHealthResultOutput) Status() pulumi.StringOutput

func (GetBackendSetHealthResultOutput) ToGetBackendSetHealthResultOutput 

func (o GetBackendSetHealthResultOutput) ToGetBackendSetHealthResultOutput() GetBackendSetHealthResultOutput

func (GetBackendSetHealthResultOutput) ToGetBackendSetHealthResultOutputWithContext 

func (o GetBackendSetHealthResultOutput) ToGetBackendSetHealthResultOutputWithContext(ctx context.Context) GetBackendSetHealthResultOutput

func (GetBackendSetHealthResultOutput) TotalBackendCount 

func (o GetBackendSetHealthResultOutput) TotalBackendCount() pulumi.IntOutput

func (GetBackendSetHealthResultOutput) UnknownStateBackendNames 

func (o GetBackendSetHealthResultOutput) UnknownStateBackendNames() pulumi.StringArrayOutput

func (GetBackendSetHealthResultOutput) WarningStateBackendNames 

func (o GetBackendSetHealthResultOutput) WarningStateBackendNames() pulumi.StringArrayOutput

type GetBackendSetsArgs 

type GetBackendSetsArgs struct {
	Filters []GetBackendSetsFilter `pulumi:"filters"`
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId string `pulumi:"networkLoadBalancerId"`
}

A collection of arguments for invoking getBackendSets.

type GetBackendSetsBackendSetCollection 

type GetBackendSetsBackendSetCollection struct {
	Items []GetBackendSetsBackendSetCollectionItem `pulumi:"items"`
}

type GetBackendSetsBackendSetCollectionArgs 

type GetBackendSetsBackendSetCollectionArgs struct {
	Items GetBackendSetsBackendSetCollectionItemArrayInput `pulumi:"items"`
}

func (GetBackendSetsBackendSetCollectionArgs) ElementType 

func (GetBackendSetsBackendSetCollectionArgs) ElementType() reflect.Type

func (GetBackendSetsBackendSetCollectionArgs) ToGetBackendSetsBackendSetCollectionOutput 

func (i GetBackendSetsBackendSetCollectionArgs) ToGetBackendSetsBackendSetCollectionOutput() GetBackendSetsBackendSetCollectionOutput

func (GetBackendSetsBackendSetCollectionArgs) ToGetBackendSetsBackendSetCollectionOutputWithContext 

func (i GetBackendSetsBackendSetCollectionArgs) ToGetBackendSetsBackendSetCollectionOutputWithContext(ctx context.Context) GetBackendSetsBackendSetCollectionOutput

type GetBackendSetsBackendSetCollectionArray 

type GetBackendSetsBackendSetCollectionArray []GetBackendSetsBackendSetCollectionInput

func (GetBackendSetsBackendSetCollectionArray) ElementType 

func (GetBackendSetsBackendSetCollectionArray) ElementType() reflect.Type

func (GetBackendSetsBackendSetCollectionArray) ToGetBackendSetsBackendSetCollectionArrayOutput 

func (i GetBackendSetsBackendSetCollectionArray) ToGetBackendSetsBackendSetCollectionArrayOutput() GetBackendSetsBackendSetCollectionArrayOutput

func (GetBackendSetsBackendSetCollectionArray) ToGetBackendSetsBackendSetCollectionArrayOutputWithContext 

func (i GetBackendSetsBackendSetCollectionArray) ToGetBackendSetsBackendSetCollectionArrayOutputWithContext(ctx context.Context) GetBackendSetsBackendSetCollectionArrayOutput

type GetBackendSetsBackendSetCollectionArrayInput 

type GetBackendSetsBackendSetCollectionArrayInput interface {
	pulumi.Input

	ToGetBackendSetsBackendSetCollectionArrayOutput() GetBackendSetsBackendSetCollectionArrayOutput
	ToGetBackendSetsBackendSetCollectionArrayOutputWithContext(context.Context) GetBackendSetsBackendSetCollectionArrayOutput
}

GetBackendSetsBackendSetCollectionArrayInput is an input type that accepts GetBackendSetsBackendSetCollectionArray and GetBackendSetsBackendSetCollectionArrayOutput values. You can construct a concrete instance of `GetBackendSetsBackendSetCollectionArrayInput` via: 

GetBackendSetsBackendSetCollectionArray{ GetBackendSetsBackendSetCollectionArgs{...} }

type GetBackendSetsBackendSetCollectionArrayOutput 

type GetBackendSetsBackendSetCollectionArrayOutput struct{ *pulumi.OutputState }

func (GetBackendSetsBackendSetCollectionArrayOutput) ElementType 

func (GetBackendSetsBackendSetCollectionArrayOutput) ElementType() reflect.Type

func (GetBackendSetsBackendSetCollectionArrayOutput) Index 

func (o GetBackendSetsBackendSetCollectionArrayOutput) Index(i pulumi.IntInput) GetBackendSetsBackendSetCollectionOutput

func (GetBackendSetsBackendSetCollectionArrayOutput) ToGetBackendSetsBackendSetCollectionArrayOutput 

func (o GetBackendSetsBackendSetCollectionArrayOutput) ToGetBackendSetsBackendSetCollectionArrayOutput() GetBackendSetsBackendSetCollectionArrayOutput

func (GetBackendSetsBackendSetCollectionArrayOutput) ToGetBackendSetsBackendSetCollectionArrayOutputWithContext 

func (o GetBackendSetsBackendSetCollectionArrayOutput) ToGetBackendSetsBackendSetCollectionArrayOutputWithContext(ctx context.Context) GetBackendSetsBackendSetCollectionArrayOutput

type GetBackendSetsBackendSetCollectionInput 

type GetBackendSetsBackendSetCollectionInput interface {
	pulumi.Input

	ToGetBackendSetsBackendSetCollectionOutput() GetBackendSetsBackendSetCollectionOutput
	ToGetBackendSetsBackendSetCollectionOutputWithContext(context.Context) GetBackendSetsBackendSetCollectionOutput
}

GetBackendSetsBackendSetCollectionInput is an input type that accepts GetBackendSetsBackendSetCollectionArgs and GetBackendSetsBackendSetCollectionOutput values. You can construct a concrete instance of `GetBackendSetsBackendSetCollectionInput` via: 

GetBackendSetsBackendSetCollectionArgs{...}

type GetBackendSetsBackendSetCollectionItem 

type GetBackendSetsBackendSetCollectionItem struct {
	// Array of backends.
	Backends []GetBackendSetsBackendSetCollectionItemBackend `pulumi:"backends"`
	// The health check policy configuration. For more information, see [Editing Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/Balance/Tasks/editinghealthcheck.htm).
	HealthCheckers []GetBackendSetsBackendSetCollectionItemHealthChecker `pulumi:"healthCheckers"`
	Id             string                                                `pulumi:"id"`
	// IP version associated with the backend set.
	IpVersion string `pulumi:"ipVersion"`
	// If enabled, the network load balancer will continue to distribute traffic in the configured distribution in the event all backends are unhealthy. The value is false by default.
	IsFailOpen bool `pulumi:"isFailOpen"`
	// If enabled existing connections will be forwarded to an alternative healthy backend as soon as current backend becomes unhealthy.
	IsInstantFailoverEnabled bool `pulumi:"isInstantFailoverEnabled"`
	// If this parameter is enabled, then the network load balancer preserves the source IP of the packet when it is forwarded to backends. Backends see the original source IP. If the isPreserveSourceDestination parameter is enabled for the network load balancer resource, then this parameter cannot be disabled. The value is true by default.
	IsPreserveSource bool `pulumi:"isPreserveSource"`
	// A user-friendly name for the backend set that must be unique and cannot be changed.
	Name string `pulumi:"name"`
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId string `pulumi:"networkLoadBalancerId"`
	// The network load balancer policy for the backend set.  Example: `FIVE_TUPLE`
	Policy string `pulumi:"policy"`
}

type GetBackendSetsBackendSetCollectionItemArgs 

type GetBackendSetsBackendSetCollectionItemArgs struct {
	// Array of backends.
	Backends GetBackendSetsBackendSetCollectionItemBackendArrayInput `pulumi:"backends"`
	// The health check policy configuration. For more information, see [Editing Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/Balance/Tasks/editinghealthcheck.htm).
	HealthCheckers GetBackendSetsBackendSetCollectionItemHealthCheckerArrayInput `pulumi:"healthCheckers"`
	Id             pulumi.StringInput                                            `pulumi:"id"`
	// IP version associated with the backend set.
	IpVersion pulumi.StringInput `pulumi:"ipVersion"`
	// If enabled, the network load balancer will continue to distribute traffic in the configured distribution in the event all backends are unhealthy. The value is false by default.
	IsFailOpen pulumi.BoolInput `pulumi:"isFailOpen"`
	// If enabled existing connections will be forwarded to an alternative healthy backend as soon as current backend becomes unhealthy.
	IsInstantFailoverEnabled pulumi.BoolInput `pulumi:"isInstantFailoverEnabled"`
	// If this parameter is enabled, then the network load balancer preserves the source IP of the packet when it is forwarded to backends. Backends see the original source IP. If the isPreserveSourceDestination parameter is enabled for the network load balancer resource, then this parameter cannot be disabled. The value is true by default.
	IsPreserveSource pulumi.BoolInput `pulumi:"isPreserveSource"`
	// A user-friendly name for the backend set that must be unique and cannot be changed.
	Name pulumi.StringInput `pulumi:"name"`
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId pulumi.StringInput `pulumi:"networkLoadBalancerId"`
	// The network load balancer policy for the backend set.  Example: `FIVE_TUPLE`
	Policy pulumi.StringInput `pulumi:"policy"`
}

func (GetBackendSetsBackendSetCollectionItemArgs) ElementType 

func (GetBackendSetsBackendSetCollectionItemArgs) ElementType() reflect.Type

func (GetBackendSetsBackendSetCollectionItemArgs) ToGetBackendSetsBackendSetCollectionItemOutput 

func (i GetBackendSetsBackendSetCollectionItemArgs) ToGetBackendSetsBackendSetCollectionItemOutput() GetBackendSetsBackendSetCollectionItemOutput

func (GetBackendSetsBackendSetCollectionItemArgs) ToGetBackendSetsBackendSetCollectionItemOutputWithContext 

func (i GetBackendSetsBackendSetCollectionItemArgs) ToGetBackendSetsBackendSetCollectionItemOutputWithContext(ctx context.Context) GetBackendSetsBackendSetCollectionItemOutput

type GetBackendSetsBackendSetCollectionItemArray 

type GetBackendSetsBackendSetCollectionItemArray []GetBackendSetsBackendSetCollectionItemInput

func (GetBackendSetsBackendSetCollectionItemArray) ElementType 

func (GetBackendSetsBackendSetCollectionItemArray) ElementType() reflect.Type

func (GetBackendSetsBackendSetCollectionItemArray) ToGetBackendSetsBackendSetCollectionItemArrayOutput 

func (i GetBackendSetsBackendSetCollectionItemArray) ToGetBackendSetsBackendSetCollectionItemArrayOutput() GetBackendSetsBackendSetCollectionItemArrayOutput

func (GetBackendSetsBackendSetCollectionItemArray) ToGetBackendSetsBackendSetCollectionItemArrayOutputWithContext 

func (i GetBackendSetsBackendSetCollectionItemArray) ToGetBackendSetsBackendSetCollectionItemArrayOutputWithContext(ctx context.Context) GetBackendSetsBackendSetCollectionItemArrayOutput

type GetBackendSetsBackendSetCollectionItemArrayInput 

type GetBackendSetsBackendSetCollectionItemArrayInput interface {
	pulumi.Input

	ToGetBackendSetsBackendSetCollectionItemArrayOutput() GetBackendSetsBackendSetCollectionItemArrayOutput
	ToGetBackendSetsBackendSetCollectionItemArrayOutputWithContext(context.Context) GetBackendSetsBackendSetCollectionItemArrayOutput
}

GetBackendSetsBackendSetCollectionItemArrayInput is an input type that accepts GetBackendSetsBackendSetCollectionItemArray and GetBackendSetsBackendSetCollectionItemArrayOutput values. You can construct a concrete instance of `GetBackendSetsBackendSetCollectionItemArrayInput` via: 

GetBackendSetsBackendSetCollectionItemArray{ GetBackendSetsBackendSetCollectionItemArgs{...} }

type GetBackendSetsBackendSetCollectionItemArrayOutput 

type GetBackendSetsBackendSetCollectionItemArrayOutput struct{ *pulumi.OutputState }

func (GetBackendSetsBackendSetCollectionItemArrayOutput) ElementType 

func (GetBackendSetsBackendSetCollectionItemArrayOutput) ElementType() reflect.Type

func (GetBackendSetsBackendSetCollectionItemArrayOutput) Index 

func (o GetBackendSetsBackendSetCollectionItemArrayOutput) Index(i pulumi.IntInput) GetBackendSetsBackendSetCollectionItemOutput

func (GetBackendSetsBackendSetCollectionItemArrayOutput) ToGetBackendSetsBackendSetCollectionItemArrayOutput 

func (o GetBackendSetsBackendSetCollectionItemArrayOutput) ToGetBackendSetsBackendSetCollectionItemArrayOutput() GetBackendSetsBackendSetCollectionItemArrayOutput

func (GetBackendSetsBackendSetCollectionItemArrayOutput) ToGetBackendSetsBackendSetCollectionItemArrayOutputWithContext 

func (o GetBackendSetsBackendSetCollectionItemArrayOutput) ToGetBackendSetsBackendSetCollectionItemArrayOutputWithContext(ctx context.Context) GetBackendSetsBackendSetCollectionItemArrayOutput

type GetBackendSetsBackendSetCollectionItemBackend 

type GetBackendSetsBackendSetCollectionItemBackend struct {
	// The IP address of the backend server. Example: `10.0.0.3`
	IpAddress string `pulumi:"ipAddress"`
	// Whether the network load balancer should treat this server as a backup unit. If `true`, then the network load balancer forwards no ingress traffic to this backend server unless all other backend servers not marked as "isBackup" fail the health check policy.  Example: `false`
	IsBackup bool `pulumi:"isBackup"`
	// Whether the network load balancer should drain this server. Servers marked "isDrain" receive no incoming traffic.  Example: `false`
	IsDrain bool `pulumi:"isDrain"`
	// Whether the network load balancer should treat this server as offline. Offline servers receive no incoming traffic.  Example: `false`
	IsOffline bool `pulumi:"isOffline"`
	// A user-friendly name for the backend set that must be unique and cannot be changed.
	Name string `pulumi:"name"`
	// The backend server port against which to run the health check. If the port is not specified, then the network load balancer uses the port information from the `Backend` object. The port must be specified if the backend port is 0.  Example: `8080`
	Port int `pulumi:"port"`
	// The IP OCID/Instance OCID associated with the backend server. Example: `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>`
	TargetId string `pulumi:"targetId"`
	// The network load balancing policy weight assigned to the server. Backend servers with a higher weight receive a larger proportion of incoming traffic. For example, a server weighted '3' receives three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/lbpolicies.htm).  Example: `3`
	Weight int `pulumi:"weight"`
}

type GetBackendSetsBackendSetCollectionItemBackendArgs 

type GetBackendSetsBackendSetCollectionItemBackendArgs struct {
	// The IP address of the backend server. Example: `10.0.0.3`
	IpAddress pulumi.StringInput `pulumi:"ipAddress"`
	// Whether the network load balancer should treat this server as a backup unit. If `true`, then the network load balancer forwards no ingress traffic to this backend server unless all other backend servers not marked as "isBackup" fail the health check policy.  Example: `false`
	IsBackup pulumi.BoolInput `pulumi:"isBackup"`
	// Whether the network load balancer should drain this server. Servers marked "isDrain" receive no incoming traffic.  Example: `false`
	IsDrain pulumi.BoolInput `pulumi:"isDrain"`
	// Whether the network load balancer should treat this server as offline. Offline servers receive no incoming traffic.  Example: `false`
	IsOffline pulumi.BoolInput `pulumi:"isOffline"`
	// A user-friendly name for the backend set that must be unique and cannot be changed.
	Name pulumi.StringInput `pulumi:"name"`
	// The backend server port against which to run the health check. If the port is not specified, then the network load balancer uses the port information from the `Backend` object. The port must be specified if the backend port is 0.  Example: `8080`
	Port pulumi.IntInput `pulumi:"port"`
	// The IP OCID/Instance OCID associated with the backend server. Example: `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>`
	TargetId pulumi.StringInput `pulumi:"targetId"`
	// The network load balancing policy weight assigned to the server. Backend servers with a higher weight receive a larger proportion of incoming traffic. For example, a server weighted '3' receives three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/lbpolicies.htm).  Example: `3`
	Weight pulumi.IntInput `pulumi:"weight"`
}

func (GetBackendSetsBackendSetCollectionItemBackendArgs) ElementType 

func (GetBackendSetsBackendSetCollectionItemBackendArgs) ElementType() reflect.Type

func (GetBackendSetsBackendSetCollectionItemBackendArgs) ToGetBackendSetsBackendSetCollectionItemBackendOutput 

func (i GetBackendSetsBackendSetCollectionItemBackendArgs) ToGetBackendSetsBackendSetCollectionItemBackendOutput() GetBackendSetsBackendSetCollectionItemBackendOutput

func (GetBackendSetsBackendSetCollectionItemBackendArgs) ToGetBackendSetsBackendSetCollectionItemBackendOutputWithContext 

func (i GetBackendSetsBackendSetCollectionItemBackendArgs) ToGetBackendSetsBackendSetCollectionItemBackendOutputWithContext(ctx context.Context) GetBackendSetsBackendSetCollectionItemBackendOutput

type GetBackendSetsBackendSetCollectionItemBackendArray 

type GetBackendSetsBackendSetCollectionItemBackendArray []GetBackendSetsBackendSetCollectionItemBackendInput

func (GetBackendSetsBackendSetCollectionItemBackendArray) ElementType 

func (GetBackendSetsBackendSetCollectionItemBackendArray) ElementType() reflect.Type

func (GetBackendSetsBackendSetCollectionItemBackendArray) ToGetBackendSetsBackendSetCollectionItemBackendArrayOutput 

func (i GetBackendSetsBackendSetCollectionItemBackendArray) ToGetBackendSetsBackendSetCollectionItemBackendArrayOutput() GetBackendSetsBackendSetCollectionItemBackendArrayOutput

func (GetBackendSetsBackendSetCollectionItemBackendArray) ToGetBackendSetsBackendSetCollectionItemBackendArrayOutputWithContext 

func (i GetBackendSetsBackendSetCollectionItemBackendArray) ToGetBackendSetsBackendSetCollectionItemBackendArrayOutputWithContext(ctx context.Context) GetBackendSetsBackendSetCollectionItemBackendArrayOutput

type GetBackendSetsBackendSetCollectionItemBackendArrayInput 

type GetBackendSetsBackendSetCollectionItemBackendArrayInput interface {
	pulumi.Input

	ToGetBackendSetsBackendSetCollectionItemBackendArrayOutput() GetBackendSetsBackendSetCollectionItemBackendArrayOutput
	ToGetBackendSetsBackendSetCollectionItemBackendArrayOutputWithContext(context.Context) GetBackendSetsBackendSetCollectionItemBackendArrayOutput
}

GetBackendSetsBackendSetCollectionItemBackendArrayInput is an input type that accepts GetBackendSetsBackendSetCollectionItemBackendArray and GetBackendSetsBackendSetCollectionItemBackendArrayOutput values. You can construct a concrete instance of `GetBackendSetsBackendSetCollectionItemBackendArrayInput` via: 

GetBackendSetsBackendSetCollectionItemBackendArray{ GetBackendSetsBackendSetCollectionItemBackendArgs{...} }

type GetBackendSetsBackendSetCollectionItemBackendArrayOutput 

type GetBackendSetsBackendSetCollectionItemBackendArrayOutput struct{ *pulumi.OutputState }

func (GetBackendSetsBackendSetCollectionItemBackendArrayOutput) ElementType 

func (GetBackendSetsBackendSetCollectionItemBackendArrayOutput) ElementType() reflect.Type

func (GetBackendSetsBackendSetCollectionItemBackendArrayOutput) Index 

func (o GetBackendSetsBackendSetCollectionItemBackendArrayOutput) Index(i pulumi.IntInput) GetBackendSetsBackendSetCollectionItemBackendOutput

func (GetBackendSetsBackendSetCollectionItemBackendArrayOutput) ToGetBackendSetsBackendSetCollectionItemBackendArrayOutput 

func (o GetBackendSetsBackendSetCollectionItemBackendArrayOutput) ToGetBackendSetsBackendSetCollectionItemBackendArrayOutput() GetBackendSetsBackendSetCollectionItemBackendArrayOutput

func (GetBackendSetsBackendSetCollectionItemBackendArrayOutput) ToGetBackendSetsBackendSetCollectionItemBackendArrayOutputWithContext 

func (o GetBackendSetsBackendSetCollectionItemBackendArrayOutput) ToGetBackendSetsBackendSetCollectionItemBackendArrayOutputWithContext(ctx context.Context) GetBackendSetsBackendSetCollectionItemBackendArrayOutput

type GetBackendSetsBackendSetCollectionItemBackendInput 

type GetBackendSetsBackendSetCollectionItemBackendInput interface {
	pulumi.Input

	ToGetBackendSetsBackendSetCollectionItemBackendOutput() GetBackendSetsBackendSetCollectionItemBackendOutput
	ToGetBackendSetsBackendSetCollectionItemBackendOutputWithContext(context.Context) GetBackendSetsBackendSetCollectionItemBackendOutput
}

GetBackendSetsBackendSetCollectionItemBackendInput is an input type that accepts GetBackendSetsBackendSetCollectionItemBackendArgs and GetBackendSetsBackendSetCollectionItemBackendOutput values. You can construct a concrete instance of `GetBackendSetsBackendSetCollectionItemBackendInput` via: 

GetBackendSetsBackendSetCollectionItemBackendArgs{...}

type GetBackendSetsBackendSetCollectionItemBackendOutput 

type GetBackendSetsBackendSetCollectionItemBackendOutput struct{ *pulumi.OutputState }

func (GetBackendSetsBackendSetCollectionItemBackendOutput) ElementType 

func (GetBackendSetsBackendSetCollectionItemBackendOutput) ElementType() reflect.Type

func (GetBackendSetsBackendSetCollectionItemBackendOutput) IpAddress 

func (o GetBackendSetsBackendSetCollectionItemBackendOutput) IpAddress() pulumi.StringOutput

The IP address of the backend server. Example: `10.0.0.3`

func (GetBackendSetsBackendSetCollectionItemBackendOutput) IsBackup 

func (o GetBackendSetsBackendSetCollectionItemBackendOutput) IsBackup() pulumi.BoolOutput

Whether the network load balancer should treat this server as a backup unit. If `true`, then the network load balancer forwards no ingress traffic to this backend server unless all other backend servers not marked as "isBackup" fail the health check policy. Example: `false`

func (GetBackendSetsBackendSetCollectionItemBackendOutput) IsDrain 

func (o GetBackendSetsBackendSetCollectionItemBackendOutput) IsDrain() pulumi.BoolOutput

Whether the network load balancer should drain this server. Servers marked "isDrain" receive no incoming traffic. Example: `false`

func (GetBackendSetsBackendSetCollectionItemBackendOutput) IsOffline 

func (o GetBackendSetsBackendSetCollectionItemBackendOutput) IsOffline() pulumi.BoolOutput

Whether the network load balancer should treat this server as offline. Offline servers receive no incoming traffic. Example: `false`

func (GetBackendSetsBackendSetCollectionItemBackendOutput) Name 

func (o GetBackendSetsBackendSetCollectionItemBackendOutput) Name() pulumi.StringOutput

A user-friendly name for the backend set that must be unique and cannot be changed.

func (GetBackendSetsBackendSetCollectionItemBackendOutput) Port 

func (o GetBackendSetsBackendSetCollectionItemBackendOutput) Port() pulumi.IntOutput

The backend server port against which to run the health check. If the port is not specified, then the network load balancer uses the port information from the `Backend` object. The port must be specified if the backend port is 0. Example: `8080`

func (GetBackendSetsBackendSetCollectionItemBackendOutput) TargetId 

func (o GetBackendSetsBackendSetCollectionItemBackendOutput) TargetId() pulumi.StringOutput

The IP OCID/Instance OCID associated with the backend server. Example: `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>`

func (GetBackendSetsBackendSetCollectionItemBackendOutput) ToGetBackendSetsBackendSetCollectionItemBackendOutput 

func (o GetBackendSetsBackendSetCollectionItemBackendOutput) ToGetBackendSetsBackendSetCollectionItemBackendOutput() GetBackendSetsBackendSetCollectionItemBackendOutput

func (GetBackendSetsBackendSetCollectionItemBackendOutput) ToGetBackendSetsBackendSetCollectionItemBackendOutputWithContext 

func (o GetBackendSetsBackendSetCollectionItemBackendOutput) ToGetBackendSetsBackendSetCollectionItemBackendOutputWithContext(ctx context.Context) GetBackendSetsBackendSetCollectionItemBackendOutput

func (GetBackendSetsBackendSetCollectionItemBackendOutput) Weight 

func (o GetBackendSetsBackendSetCollectionItemBackendOutput) Weight() pulumi.IntOutput

The network load balancing policy weight assigned to the server. Backend servers with a higher weight receive a larger proportion of incoming traffic. For example, a server weighted '3' receives three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/lbpolicies.htm). Example: `3`

type GetBackendSetsBackendSetCollectionItemHealthChecker 

type GetBackendSetsBackendSetCollectionItemHealthChecker struct {
	// DNS healthcheck configurations.
	Dns []GetBackendSetsBackendSetCollectionItemHealthCheckerDn `pulumi:"dns"`
	// The interval between health checks, in milliseconds. The default value is 10000 (10 seconds).  Example: `10000`
	IntervalInMillis int `pulumi:"intervalInMillis"`
	// The backend server port against which to run the health check. If the port is not specified, then the network load balancer uses the port information from the `Backend` object. The port must be specified if the backend port is 0.  Example: `8080`
	Port int `pulumi:"port"`
	// The protocol the health check must use; either HTTP, HTTPS, UDP, TCP or DNS.  Example: `HTTP`
	Protocol string `pulumi:"protocol"`
	// Base64 encoded pattern to be sent as UDP or TCP health check probe.
	RequestData string `pulumi:"requestData"`
	// A regular expression for parsing the response body from the backend server.  Example: `^((?!false).|\s)*$`
	ResponseBodyRegex string `pulumi:"responseBodyRegex"`
	// Base64 encoded pattern to be validated as UDP or TCP health check probe response.
	ResponseData string `pulumi:"responseData"`
	// The number of retries to attempt before a backend server is considered "unhealthy". This number also applies when recovering a server to the "healthy" state. The default value is 3.  Example: `3`
	Retries int `pulumi:"retries"`
	// The status code a healthy backend server should return. If you configure the health check policy to use the HTTP protocol, then you can use common HTTP status codes such as "200".  Example: `200`
	ReturnCode int `pulumi:"returnCode"`
	// The maximum time, in milliseconds, to wait for a reply to a health check. A health check is successful only if a reply returns within this timeout period. The default value is 3000 (3 seconds).  Example: `3000`
	TimeoutInMillis int `pulumi:"timeoutInMillis"`
	// The path against which to run the health check.  Example: `/healthcheck`
	UrlPath string `pulumi:"urlPath"`
}

type GetBackendSetsBackendSetCollectionItemHealthCheckerArgs 

type GetBackendSetsBackendSetCollectionItemHealthCheckerArgs struct {
	// DNS healthcheck configurations.
	Dns GetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayInput `pulumi:"dns"`
	// The interval between health checks, in milliseconds. The default value is 10000 (10 seconds).  Example: `10000`
	IntervalInMillis pulumi.IntInput `pulumi:"intervalInMillis"`
	// The backend server port against which to run the health check. If the port is not specified, then the network load balancer uses the port information from the `Backend` object. The port must be specified if the backend port is 0.  Example: `8080`
	Port pulumi.IntInput `pulumi:"port"`
	// The protocol the health check must use; either HTTP, HTTPS, UDP, TCP or DNS.  Example: `HTTP`
	Protocol pulumi.StringInput `pulumi:"protocol"`
	// Base64 encoded pattern to be sent as UDP or TCP health check probe.
	RequestData pulumi.StringInput `pulumi:"requestData"`
	// A regular expression for parsing the response body from the backend server.  Example: `^((?!false).|\s)*$`
	ResponseBodyRegex pulumi.StringInput `pulumi:"responseBodyRegex"`
	// Base64 encoded pattern to be validated as UDP or TCP health check probe response.
	ResponseData pulumi.StringInput `pulumi:"responseData"`
	// The number of retries to attempt before a backend server is considered "unhealthy". This number also applies when recovering a server to the "healthy" state. The default value is 3.  Example: `3`
	Retries pulumi.IntInput `pulumi:"retries"`
	// The status code a healthy backend server should return. If you configure the health check policy to use the HTTP protocol, then you can use common HTTP status codes such as "200".  Example: `200`
	ReturnCode pulumi.IntInput `pulumi:"returnCode"`
	// The maximum time, in milliseconds, to wait for a reply to a health check. A health check is successful only if a reply returns within this timeout period. The default value is 3000 (3 seconds).  Example: `3000`
	TimeoutInMillis pulumi.IntInput `pulumi:"timeoutInMillis"`
	// The path against which to run the health check.  Example: `/healthcheck`
	UrlPath pulumi.StringInput `pulumi:"urlPath"`
}

func (GetBackendSetsBackendSetCollectionItemHealthCheckerArgs) ElementType 

func (GetBackendSetsBackendSetCollectionItemHealthCheckerArgs) ElementType() reflect.Type

func (GetBackendSetsBackendSetCollectionItemHealthCheckerArgs) ToGetBackendSetsBackendSetCollectionItemHealthCheckerOutput 

func (i GetBackendSetsBackendSetCollectionItemHealthCheckerArgs) ToGetBackendSetsBackendSetCollectionItemHealthCheckerOutput() GetBackendSetsBackendSetCollectionItemHealthCheckerOutput

func (GetBackendSetsBackendSetCollectionItemHealthCheckerArgs) ToGetBackendSetsBackendSetCollectionItemHealthCheckerOutputWithContext 

func (i GetBackendSetsBackendSetCollectionItemHealthCheckerArgs) ToGetBackendSetsBackendSetCollectionItemHealthCheckerOutputWithContext(ctx context.Context) GetBackendSetsBackendSetCollectionItemHealthCheckerOutput

type GetBackendSetsBackendSetCollectionItemHealthCheckerArray 

type GetBackendSetsBackendSetCollectionItemHealthCheckerArray []GetBackendSetsBackendSetCollectionItemHealthCheckerInput

func (GetBackendSetsBackendSetCollectionItemHealthCheckerArray) ElementType 

func (GetBackendSetsBackendSetCollectionItemHealthCheckerArray) ElementType() reflect.Type

func (GetBackendSetsBackendSetCollectionItemHealthCheckerArray) ToGetBackendSetsBackendSetCollectionItemHealthCheckerArrayOutput 

func (i GetBackendSetsBackendSetCollectionItemHealthCheckerArray) ToGetBackendSetsBackendSetCollectionItemHealthCheckerArrayOutput() GetBackendSetsBackendSetCollectionItemHealthCheckerArrayOutput

func (GetBackendSetsBackendSetCollectionItemHealthCheckerArray) ToGetBackendSetsBackendSetCollectionItemHealthCheckerArrayOutputWithContext 

func (i GetBackendSetsBackendSetCollectionItemHealthCheckerArray) ToGetBackendSetsBackendSetCollectionItemHealthCheckerArrayOutputWithContext(ctx context.Context) GetBackendSetsBackendSetCollectionItemHealthCheckerArrayOutput

type GetBackendSetsBackendSetCollectionItemHealthCheckerArrayInput 

type GetBackendSetsBackendSetCollectionItemHealthCheckerArrayInput interface {
	pulumi.Input

	ToGetBackendSetsBackendSetCollectionItemHealthCheckerArrayOutput() GetBackendSetsBackendSetCollectionItemHealthCheckerArrayOutput
	ToGetBackendSetsBackendSetCollectionItemHealthCheckerArrayOutputWithContext(context.Context) GetBackendSetsBackendSetCollectionItemHealthCheckerArrayOutput
}

GetBackendSetsBackendSetCollectionItemHealthCheckerArrayInput is an input type that accepts GetBackendSetsBackendSetCollectionItemHealthCheckerArray and GetBackendSetsBackendSetCollectionItemHealthCheckerArrayOutput values. You can construct a concrete instance of `GetBackendSetsBackendSetCollectionItemHealthCheckerArrayInput` via: 

GetBackendSetsBackendSetCollectionItemHealthCheckerArray{ GetBackendSetsBackendSetCollectionItemHealthCheckerArgs{...} }

type GetBackendSetsBackendSetCollectionItemHealthCheckerArrayOutput 

type GetBackendSetsBackendSetCollectionItemHealthCheckerArrayOutput struct{ *pulumi.OutputState }

func (GetBackendSetsBackendSetCollectionItemHealthCheckerArrayOutput) ElementType 

func (GetBackendSetsBackendSetCollectionItemHealthCheckerArrayOutput) ElementType() reflect.Type

func (GetBackendSetsBackendSetCollectionItemHealthCheckerArrayOutput) Index 

func (o GetBackendSetsBackendSetCollectionItemHealthCheckerArrayOutput) Index(i pulumi.IntInput) GetBackendSetsBackendSetCollectionItemHealthCheckerOutput

func (GetBackendSetsBackendSetCollectionItemHealthCheckerArrayOutput) ToGetBackendSetsBackendSetCollectionItemHealthCheckerArrayOutput 

func (o GetBackendSetsBackendSetCollectionItemHealthCheckerArrayOutput) ToGetBackendSetsBackendSetCollectionItemHealthCheckerArrayOutput() GetBackendSetsBackendSetCollectionItemHealthCheckerArrayOutput

func (GetBackendSetsBackendSetCollectionItemHealthCheckerArrayOutput) ToGetBackendSetsBackendSetCollectionItemHealthCheckerArrayOutputWithContext 

func (o GetBackendSetsBackendSetCollectionItemHealthCheckerArrayOutput) ToGetBackendSetsBackendSetCollectionItemHealthCheckerArrayOutputWithContext(ctx context.Context) GetBackendSetsBackendSetCollectionItemHealthCheckerArrayOutput

type GetBackendSetsBackendSetCollectionItemHealthCheckerDn 

type GetBackendSetsBackendSetCollectionItemHealthCheckerDn struct {
	// The absolute fully-qualified domain name to perform periodic DNS queries. If not provided, an extra dot will be added at the end of a domain name during the query.
	DomainName string `pulumi:"domainName"`
	// The class the dns health check query to use; either IN or CH.  Example: `IN`
	QueryClass string `pulumi:"queryClass"`
	// The type the dns health check query to use; A, AAAA, TXT.  Example: `A`
	QueryType string `pulumi:"queryType"`
	// An array that represents accepetable RCODE values for DNS query response. Example: ["NOERROR", "NXDOMAIN"]
	Rcodes []string `pulumi:"rcodes"`
	// DNS transport protocol; either UDP or TCP.  Example: `UDP`
	TransportProtocol string `pulumi:"transportProtocol"`
}

type GetBackendSetsBackendSetCollectionItemHealthCheckerDnArgs 

type GetBackendSetsBackendSetCollectionItemHealthCheckerDnArgs struct {
	// The absolute fully-qualified domain name to perform periodic DNS queries. If not provided, an extra dot will be added at the end of a domain name during the query.
	DomainName pulumi.StringInput `pulumi:"domainName"`
	// The class the dns health check query to use; either IN or CH.  Example: `IN`
	QueryClass pulumi.StringInput `pulumi:"queryClass"`
	// The type the dns health check query to use; A, AAAA, TXT.  Example: `A`
	QueryType pulumi.StringInput `pulumi:"queryType"`
	// An array that represents accepetable RCODE values for DNS query response. Example: ["NOERROR", "NXDOMAIN"]
	Rcodes pulumi.StringArrayInput `pulumi:"rcodes"`
	// DNS transport protocol; either UDP or TCP.  Example: `UDP`
	TransportProtocol pulumi.StringInput `pulumi:"transportProtocol"`
}

func (GetBackendSetsBackendSetCollectionItemHealthCheckerDnArgs) ElementType 

func (GetBackendSetsBackendSetCollectionItemHealthCheckerDnArgs) ElementType() reflect.Type

func (GetBackendSetsBackendSetCollectionItemHealthCheckerDnArgs) ToGetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput 

func (i GetBackendSetsBackendSetCollectionItemHealthCheckerDnArgs) ToGetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput() GetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput

func (GetBackendSetsBackendSetCollectionItemHealthCheckerDnArgs) ToGetBackendSetsBackendSetCollectionItemHealthCheckerDnOutputWithContext 

func (i GetBackendSetsBackendSetCollectionItemHealthCheckerDnArgs) ToGetBackendSetsBackendSetCollectionItemHealthCheckerDnOutputWithContext(ctx context.Context) GetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput

type GetBackendSetsBackendSetCollectionItemHealthCheckerDnArray 

type GetBackendSetsBackendSetCollectionItemHealthCheckerDnArray []GetBackendSetsBackendSetCollectionItemHealthCheckerDnInput

func (GetBackendSetsBackendSetCollectionItemHealthCheckerDnArray) ElementType 

func (GetBackendSetsBackendSetCollectionItemHealthCheckerDnArray) ElementType() reflect.Type

func (GetBackendSetsBackendSetCollectionItemHealthCheckerDnArray) ToGetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayOutput 

func (i GetBackendSetsBackendSetCollectionItemHealthCheckerDnArray) ToGetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayOutput() GetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayOutput

func (GetBackendSetsBackendSetCollectionItemHealthCheckerDnArray) ToGetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayOutputWithContext 

func (i GetBackendSetsBackendSetCollectionItemHealthCheckerDnArray) ToGetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayOutputWithContext(ctx context.Context) GetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayOutput

type GetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayInput 

type GetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayInput interface {
	pulumi.Input

	ToGetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayOutput() GetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayOutput
	ToGetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayOutputWithContext(context.Context) GetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayOutput
}

GetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayInput is an input type that accepts GetBackendSetsBackendSetCollectionItemHealthCheckerDnArray and GetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayOutput values. You can construct a concrete instance of `GetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayInput` via: 

GetBackendSetsBackendSetCollectionItemHealthCheckerDnArray{ GetBackendSetsBackendSetCollectionItemHealthCheckerDnArgs{...} }

type GetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayOutput 

type GetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayOutput struct{ *pulumi.OutputState }

func (GetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayOutput) ElementType 

func (GetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayOutput) ElementType() reflect.Type

func (GetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayOutput) Index 

func (o GetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayOutput) Index(i pulumi.IntInput) GetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput

func (GetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayOutput) ToGetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayOutput 

func (o GetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayOutput) ToGetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayOutput() GetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayOutput

func (GetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayOutput) ToGetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayOutputWithContext 

func (o GetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayOutput) ToGetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayOutputWithContext(ctx context.Context) GetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayOutput

type GetBackendSetsBackendSetCollectionItemHealthCheckerDnInput 

type GetBackendSetsBackendSetCollectionItemHealthCheckerDnInput interface {
	pulumi.Input

	ToGetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput() GetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput
	ToGetBackendSetsBackendSetCollectionItemHealthCheckerDnOutputWithContext(context.Context) GetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput
}

GetBackendSetsBackendSetCollectionItemHealthCheckerDnInput is an input type that accepts GetBackendSetsBackendSetCollectionItemHealthCheckerDnArgs and GetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput values. You can construct a concrete instance of `GetBackendSetsBackendSetCollectionItemHealthCheckerDnInput` via: 

GetBackendSetsBackendSetCollectionItemHealthCheckerDnArgs{...}

type GetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput 

type GetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput struct{ *pulumi.OutputState }

func (GetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput) DomainName 

func (o GetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput) DomainName() pulumi.StringOutput

The absolute fully-qualified domain name to perform periodic DNS queries. If not provided, an extra dot will be added at the end of a domain name during the query.

func (GetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput) ElementType 

func (GetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput) ElementType() reflect.Type

func (GetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput) QueryClass 

func (o GetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput) QueryClass() pulumi.StringOutput

The class the dns health check query to use; either IN or CH. Example: `IN`

func (GetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput) QueryType 

func (o GetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput) QueryType() pulumi.StringOutput

The type the dns health check query to use; A, AAAA, TXT. Example: `A`

func (GetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput) Rcodes 

func (o GetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput) Rcodes() pulumi.StringArrayOutput

An array that represents accepetable RCODE values for DNS query response. Example: ["NOERROR", "NXDOMAIN"]

func (GetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput) ToGetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput 

func (o GetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput) ToGetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput() GetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput

func (GetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput) ToGetBackendSetsBackendSetCollectionItemHealthCheckerDnOutputWithContext 

func (o GetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput) ToGetBackendSetsBackendSetCollectionItemHealthCheckerDnOutputWithContext(ctx context.Context) GetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput

func (GetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput) TransportProtocol 

func (o GetBackendSetsBackendSetCollectionItemHealthCheckerDnOutput) TransportProtocol() pulumi.StringOutput

DNS transport protocol; either UDP or TCP. Example: `UDP`

type GetBackendSetsBackendSetCollectionItemHealthCheckerInput 

type GetBackendSetsBackendSetCollectionItemHealthCheckerInput interface {
	pulumi.Input

	ToGetBackendSetsBackendSetCollectionItemHealthCheckerOutput() GetBackendSetsBackendSetCollectionItemHealthCheckerOutput
	ToGetBackendSetsBackendSetCollectionItemHealthCheckerOutputWithContext(context.Context) GetBackendSetsBackendSetCollectionItemHealthCheckerOutput
}

GetBackendSetsBackendSetCollectionItemHealthCheckerInput is an input type that accepts GetBackendSetsBackendSetCollectionItemHealthCheckerArgs and GetBackendSetsBackendSetCollectionItemHealthCheckerOutput values. You can construct a concrete instance of `GetBackendSetsBackendSetCollectionItemHealthCheckerInput` via: 

GetBackendSetsBackendSetCollectionItemHealthCheckerArgs{...}

type GetBackendSetsBackendSetCollectionItemHealthCheckerOutput 

type GetBackendSetsBackendSetCollectionItemHealthCheckerOutput struct{ *pulumi.OutputState }

func (GetBackendSetsBackendSetCollectionItemHealthCheckerOutput) Dns 

func (o GetBackendSetsBackendSetCollectionItemHealthCheckerOutput) Dns() GetBackendSetsBackendSetCollectionItemHealthCheckerDnArrayOutput

DNS healthcheck configurations.

func (GetBackendSetsBackendSetCollectionItemHealthCheckerOutput) ElementType 

func (GetBackendSetsBackendSetCollectionItemHealthCheckerOutput) ElementType() reflect.Type

func (GetBackendSetsBackendSetCollectionItemHealthCheckerOutput) IntervalInMillis 

func (o GetBackendSetsBackendSetCollectionItemHealthCheckerOutput) IntervalInMillis() pulumi.IntOutput

The interval between health checks, in milliseconds. The default value is 10000 (10 seconds). Example: `10000`

func (GetBackendSetsBackendSetCollectionItemHealthCheckerOutput) Port 

func (o GetBackendSetsBackendSetCollectionItemHealthCheckerOutput) Port() pulumi.IntOutput

The backend server port against which to run the health check. If the port is not specified, then the network load balancer uses the port information from the `Backend` object. The port must be specified if the backend port is 0. Example: `8080`

func (GetBackendSetsBackendSetCollectionItemHealthCheckerOutput) Protocol 

func (o GetBackendSetsBackendSetCollectionItemHealthCheckerOutput) Protocol() pulumi.StringOutput

The protocol the health check must use; either HTTP, HTTPS, UDP, TCP or DNS. Example: `HTTP`

func (GetBackendSetsBackendSetCollectionItemHealthCheckerOutput) RequestData 

func (o GetBackendSetsBackendSetCollectionItemHealthCheckerOutput) RequestData() pulumi.StringOutput

Base64 encoded pattern to be sent as UDP or TCP health check probe.

func (GetBackendSetsBackendSetCollectionItemHealthCheckerOutput) ResponseBodyRegex 

func (o GetBackendSetsBackendSetCollectionItemHealthCheckerOutput) ResponseBodyRegex() pulumi.StringOutput

A regular expression for parsing the response body from the backend server. Example: `^((?!false).|\s)*$`

func (GetBackendSetsBackendSetCollectionItemHealthCheckerOutput) ResponseData 

func (o GetBackendSetsBackendSetCollectionItemHealthCheckerOutput) ResponseData() pulumi.StringOutput

Base64 encoded pattern to be validated as UDP or TCP health check probe response.

func (GetBackendSetsBackendSetCollectionItemHealthCheckerOutput) Retries 

func (o GetBackendSetsBackendSetCollectionItemHealthCheckerOutput) Retries() pulumi.IntOutput

The number of retries to attempt before a backend server is considered "unhealthy". This number also applies when recovering a server to the "healthy" state. The default value is 3. Example: `3`

func (GetBackendSetsBackendSetCollectionItemHealthCheckerOutput) ReturnCode 

func (o GetBackendSetsBackendSetCollectionItemHealthCheckerOutput) ReturnCode() pulumi.IntOutput

The status code a healthy backend server should return. If you configure the health check policy to use the HTTP protocol, then you can use common HTTP status codes such as "200". Example: `200`

func (GetBackendSetsBackendSetCollectionItemHealthCheckerOutput) TimeoutInMillis 

func (o GetBackendSetsBackendSetCollectionItemHealthCheckerOutput) TimeoutInMillis() pulumi.IntOutput

The maximum time, in milliseconds, to wait for a reply to a health check. A health check is successful only if a reply returns within this timeout period. The default value is 3000 (3 seconds). Example: `3000`

func (GetBackendSetsBackendSetCollectionItemHealthCheckerOutput) ToGetBackendSetsBackendSetCollectionItemHealthCheckerOutput 

func (o GetBackendSetsBackendSetCollectionItemHealthCheckerOutput) ToGetBackendSetsBackendSetCollectionItemHealthCheckerOutput() GetBackendSetsBackendSetCollectionItemHealthCheckerOutput

func (GetBackendSetsBackendSetCollectionItemHealthCheckerOutput) ToGetBackendSetsBackendSetCollectionItemHealthCheckerOutputWithContext 

func (o GetBackendSetsBackendSetCollectionItemHealthCheckerOutput) ToGetBackendSetsBackendSetCollectionItemHealthCheckerOutputWithContext(ctx context.Context) GetBackendSetsBackendSetCollectionItemHealthCheckerOutput

func (GetBackendSetsBackendSetCollectionItemHealthCheckerOutput) UrlPath 

func (o GetBackendSetsBackendSetCollectionItemHealthCheckerOutput) UrlPath() pulumi.StringOutput

The path against which to run the health check. Example: `/healthcheck`

type GetBackendSetsBackendSetCollectionItemInput 

type GetBackendSetsBackendSetCollectionItemInput interface {
	pulumi.Input

	ToGetBackendSetsBackendSetCollectionItemOutput() GetBackendSetsBackendSetCollectionItemOutput
	ToGetBackendSetsBackendSetCollectionItemOutputWithContext(context.Context) GetBackendSetsBackendSetCollectionItemOutput
}

GetBackendSetsBackendSetCollectionItemInput is an input type that accepts GetBackendSetsBackendSetCollectionItemArgs and GetBackendSetsBackendSetCollectionItemOutput values. You can construct a concrete instance of `GetBackendSetsBackendSetCollectionItemInput` via: 

GetBackendSetsBackendSetCollectionItemArgs{...}

type GetBackendSetsBackendSetCollectionItemOutput 

type GetBackendSetsBackendSetCollectionItemOutput struct{ *pulumi.OutputState }

func (GetBackendSetsBackendSetCollectionItemOutput) Backends 

func (o GetBackendSetsBackendSetCollectionItemOutput) Backends() GetBackendSetsBackendSetCollectionItemBackendArrayOutput

Array of backends.

func (GetBackendSetsBackendSetCollectionItemOutput) ElementType 

func (GetBackendSetsBackendSetCollectionItemOutput) ElementType() reflect.Type

func (GetBackendSetsBackendSetCollectionItemOutput) HealthCheckers 

func (o GetBackendSetsBackendSetCollectionItemOutput) HealthCheckers() GetBackendSetsBackendSetCollectionItemHealthCheckerArrayOutput

The health check policy configuration. For more information, see [Editing Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/Balance/Tasks/editinghealthcheck.htm).

func (GetBackendSetsBackendSetCollectionItemOutput) Id 

func (o GetBackendSetsBackendSetCollectionItemOutput) Id() pulumi.StringOutput

func (GetBackendSetsBackendSetCollectionItemOutput) IpVersion 

func (o GetBackendSetsBackendSetCollectionItemOutput) IpVersion() pulumi.StringOutput

IP version associated with the backend set.

func (GetBackendSetsBackendSetCollectionItemOutput) IsFailOpen 

func (o GetBackendSetsBackendSetCollectionItemOutput) IsFailOpen() pulumi.BoolOutput

If enabled, the network load balancer will continue to distribute traffic in the configured distribution in the event all backends are unhealthy. The value is false by default.

func (GetBackendSetsBackendSetCollectionItemOutput) IsInstantFailoverEnabled 

func (o GetBackendSetsBackendSetCollectionItemOutput) IsInstantFailoverEnabled() pulumi.BoolOutput

If enabled existing connections will be forwarded to an alternative healthy backend as soon as current backend becomes unhealthy.

func (GetBackendSetsBackendSetCollectionItemOutput) IsPreserveSource 

func (o GetBackendSetsBackendSetCollectionItemOutput) IsPreserveSource() pulumi.BoolOutput

If this parameter is enabled, then the network load balancer preserves the source IP of the packet when it is forwarded to backends. Backends see the original source IP. If the isPreserveSourceDestination parameter is enabled for the network load balancer resource, then this parameter cannot be disabled. The value is true by default.

func (GetBackendSetsBackendSetCollectionItemOutput) Name 

func (o GetBackendSetsBackendSetCollectionItemOutput) Name() pulumi.StringOutput

A user-friendly name for the backend set that must be unique and cannot be changed.

func (GetBackendSetsBackendSetCollectionItemOutput) NetworkLoadBalancerId 

func (o GetBackendSetsBackendSetCollectionItemOutput) NetworkLoadBalancerId() pulumi.StringOutput

The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.

func (GetBackendSetsBackendSetCollectionItemOutput) Policy 

func (o GetBackendSetsBackendSetCollectionItemOutput) Policy() pulumi.StringOutput

The network load balancer policy for the backend set. Example: `FIVE_TUPLE`

func (GetBackendSetsBackendSetCollectionItemOutput) ToGetBackendSetsBackendSetCollectionItemOutput 

func (o GetBackendSetsBackendSetCollectionItemOutput) ToGetBackendSetsBackendSetCollectionItemOutput() GetBackendSetsBackendSetCollectionItemOutput

func (GetBackendSetsBackendSetCollectionItemOutput) ToGetBackendSetsBackendSetCollectionItemOutputWithContext 

func (o GetBackendSetsBackendSetCollectionItemOutput) ToGetBackendSetsBackendSetCollectionItemOutputWithContext(ctx context.Context) GetBackendSetsBackendSetCollectionItemOutput

type GetBackendSetsBackendSetCollectionOutput 

type GetBackendSetsBackendSetCollectionOutput struct{ *pulumi.OutputState }

func (GetBackendSetsBackendSetCollectionOutput) ElementType 

func (GetBackendSetsBackendSetCollectionOutput) ElementType() reflect.Type

func (GetBackendSetsBackendSetCollectionOutput) Items 

func (o GetBackendSetsBackendSetCollectionOutput) Items() GetBackendSetsBackendSetCollectionItemArrayOutput

func (GetBackendSetsBackendSetCollectionOutput) ToGetBackendSetsBackendSetCollectionOutput 

func (o GetBackendSetsBackendSetCollectionOutput) ToGetBackendSetsBackendSetCollectionOutput() GetBackendSetsBackendSetCollectionOutput

func (GetBackendSetsBackendSetCollectionOutput) ToGetBackendSetsBackendSetCollectionOutputWithContext 

func (o GetBackendSetsBackendSetCollectionOutput) ToGetBackendSetsBackendSetCollectionOutputWithContext(ctx context.Context) GetBackendSetsBackendSetCollectionOutput

type GetBackendSetsFilter 

type GetBackendSetsFilter struct {
	// A user-friendly name for the backend set that must be unique and cannot be changed.
	Name   string   `pulumi:"name"`
	Regex  *bool    `pulumi:"regex"`
	Values []string `pulumi:"values"`
}

type GetBackendSetsFilterArgs 

type GetBackendSetsFilterArgs struct {
	// A user-friendly name for the backend set that must be unique and cannot be changed.
	Name   pulumi.StringInput      `pulumi:"name"`
	Regex  pulumi.BoolPtrInput     `pulumi:"regex"`
	Values pulumi.StringArrayInput `pulumi:"values"`
}

func (GetBackendSetsFilterArgs) ElementType 

func (GetBackendSetsFilterArgs) ElementType() reflect.Type

func (GetBackendSetsFilterArgs) ToGetBackendSetsFilterOutput 

func (i GetBackendSetsFilterArgs) ToGetBackendSetsFilterOutput() GetBackendSetsFilterOutput

func (GetBackendSetsFilterArgs) ToGetBackendSetsFilterOutputWithContext 

func (i GetBackendSetsFilterArgs) ToGetBackendSetsFilterOutputWithContext(ctx context.Context) GetBackendSetsFilterOutput

type GetBackendSetsFilterArray 

type GetBackendSetsFilterArray []GetBackendSetsFilterInput

func (GetBackendSetsFilterArray) ElementType 

func (GetBackendSetsFilterArray) ElementType() reflect.Type

func (GetBackendSetsFilterArray) ToGetBackendSetsFilterArrayOutput 

func (i GetBackendSetsFilterArray) ToGetBackendSetsFilterArrayOutput() GetBackendSetsFilterArrayOutput

func (GetBackendSetsFilterArray) ToGetBackendSetsFilterArrayOutputWithContext 

func (i GetBackendSetsFilterArray) ToGetBackendSetsFilterArrayOutputWithContext(ctx context.Context) GetBackendSetsFilterArrayOutput

type GetBackendSetsFilterArrayInput 

type GetBackendSetsFilterArrayInput interface {
	pulumi.Input

	ToGetBackendSetsFilterArrayOutput() GetBackendSetsFilterArrayOutput
	ToGetBackendSetsFilterArrayOutputWithContext(context.Context) GetBackendSetsFilterArrayOutput
}

GetBackendSetsFilterArrayInput is an input type that accepts GetBackendSetsFilterArray and GetBackendSetsFilterArrayOutput values. You can construct a concrete instance of `GetBackendSetsFilterArrayInput` via: 

GetBackendSetsFilterArray{ GetBackendSetsFilterArgs{...} }

type GetBackendSetsFilterArrayOutput 

type GetBackendSetsFilterArrayOutput struct{ *pulumi.OutputState }

func (GetBackendSetsFilterArrayOutput) ElementType 

func (GetBackendSetsFilterArrayOutput) ElementType() reflect.Type

func (GetBackendSetsFilterArrayOutput) Index 

func (o GetBackendSetsFilterArrayOutput) Index(i pulumi.IntInput) GetBackendSetsFilterOutput

func (GetBackendSetsFilterArrayOutput) ToGetBackendSetsFilterArrayOutput 

func (o GetBackendSetsFilterArrayOutput) ToGetBackendSetsFilterArrayOutput() GetBackendSetsFilterArrayOutput

func (GetBackendSetsFilterArrayOutput) ToGetBackendSetsFilterArrayOutputWithContext 

func (o GetBackendSetsFilterArrayOutput) ToGetBackendSetsFilterArrayOutputWithContext(ctx context.Context) GetBackendSetsFilterArrayOutput

type GetBackendSetsFilterInput 

type GetBackendSetsFilterInput interface {
	pulumi.Input

	ToGetBackendSetsFilterOutput() GetBackendSetsFilterOutput
	ToGetBackendSetsFilterOutputWithContext(context.Context) GetBackendSetsFilterOutput
}

GetBackendSetsFilterInput is an input type that accepts GetBackendSetsFilterArgs and GetBackendSetsFilterOutput values. You can construct a concrete instance of `GetBackendSetsFilterInput` via: 

GetBackendSetsFilterArgs{...}

type GetBackendSetsFilterOutput 

type GetBackendSetsFilterOutput struct{ *pulumi.OutputState }

func (GetBackendSetsFilterOutput) ElementType 

func (GetBackendSetsFilterOutput) ElementType() reflect.Type

func (GetBackendSetsFilterOutput) Name 

func (o GetBackendSetsFilterOutput) Name() pulumi.StringOutput

A user-friendly name for the backend set that must be unique and cannot be changed.

func (GetBackendSetsFilterOutput) Regex 

func (o GetBackendSetsFilterOutput) Regex() pulumi.BoolPtrOutput

func (GetBackendSetsFilterOutput) ToGetBackendSetsFilterOutput 

func (o GetBackendSetsFilterOutput) ToGetBackendSetsFilterOutput() GetBackendSetsFilterOutput

func (GetBackendSetsFilterOutput) ToGetBackendSetsFilterOutputWithContext 

func (o GetBackendSetsFilterOutput) ToGetBackendSetsFilterOutputWithContext(ctx context.Context) GetBackendSetsFilterOutput

func (GetBackendSetsFilterOutput) Values 

func (o GetBackendSetsFilterOutput) Values() pulumi.StringArrayOutput

type GetBackendSetsOutputArgs 

type GetBackendSetsOutputArgs struct {
	Filters GetBackendSetsFilterArrayInput `pulumi:"filters"`
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId pulumi.StringInput `pulumi:"networkLoadBalancerId"`
}

A collection of arguments for invoking getBackendSets.

func (GetBackendSetsOutputArgs) ElementType 

func (GetBackendSetsOutputArgs) ElementType() reflect.Type

type GetBackendSetsResult 

type GetBackendSetsResult struct {
	// The list of backend_set_collection.
	BackendSetCollections []GetBackendSetsBackendSetCollection `pulumi:"backendSetCollections"`
	Filters               []GetBackendSetsFilter               `pulumi:"filters"`
	// The provider-assigned unique ID for this managed resource.
	Id                    string `pulumi:"id"`
	NetworkLoadBalancerId string `pulumi:"networkLoadBalancerId"`
}

A collection of values returned by getBackendSets.

func GetBackendSets 

func GetBackendSets(ctx *pulumi.Context, args *GetBackendSetsArgs, opts ...pulumi.InvokeOption) (*GetBackendSetsResult, error)

This data source provides the list of Backend Sets in Oracle Cloud Infrastructure Network Load Balancer service.

Lists all backend sets associated with a given network load balancer.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-oci/sdk/v2/go/oci/NetworkLoadBalancer"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := NetworkLoadBalancer.GetBackendSets(ctx, &networkloadbalancer.GetBackendSetsArgs{
			NetworkLoadBalancerId: testNetworkLoadBalancer.Id,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type GetBackendSetsResultOutput 

type GetBackendSetsResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getBackendSets.

func GetBackendSetsOutput 

func GetBackendSetsOutput(ctx *pulumi.Context, args GetBackendSetsOutputArgs, opts ...pulumi.InvokeOption) GetBackendSetsResultOutput

func (GetBackendSetsResultOutput) BackendSetCollections 

func (o GetBackendSetsResultOutput) BackendSetCollections() GetBackendSetsBackendSetCollectionArrayOutput

The list of backend_set_collection.

func (GetBackendSetsResultOutput) ElementType 

func (GetBackendSetsResultOutput) ElementType() reflect.Type

func (GetBackendSetsResultOutput) Filters 

func (o GetBackendSetsResultOutput) Filters() GetBackendSetsFilterArrayOutput

func (GetBackendSetsResultOutput) Id 

func (o GetBackendSetsResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (GetBackendSetsResultOutput) NetworkLoadBalancerId 

func (o GetBackendSetsResultOutput) NetworkLoadBalancerId() pulumi.StringOutput

func (GetBackendSetsResultOutput) ToGetBackendSetsResultOutput 

func (o GetBackendSetsResultOutput) ToGetBackendSetsResultOutput() GetBackendSetsResultOutput

func (GetBackendSetsResultOutput) ToGetBackendSetsResultOutputWithContext 

func (o GetBackendSetsResultOutput) ToGetBackendSetsResultOutputWithContext(ctx context.Context) GetBackendSetsResultOutput

type GetBackendsArgs 

type GetBackendsArgs struct {
	// The name of the backend set associated with the backend servers.  Example: `exampleBackendSet`
	BackendSetName string              `pulumi:"backendSetName"`
	Filters        []GetBackendsFilter `pulumi:"filters"`
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId string `pulumi:"networkLoadBalancerId"`
}

A collection of arguments for invoking getBackends.

type GetBackendsBackendCollection 

type GetBackendsBackendCollection struct {
	Items []GetBackendsBackendCollectionItem `pulumi:"items"`
}

type GetBackendsBackendCollectionArgs 

type GetBackendsBackendCollectionArgs struct {
	Items GetBackendsBackendCollectionItemArrayInput `pulumi:"items"`
}

func (GetBackendsBackendCollectionArgs) ElementType 

func (GetBackendsBackendCollectionArgs) ElementType() reflect.Type

func (GetBackendsBackendCollectionArgs) ToGetBackendsBackendCollectionOutput 

func (i GetBackendsBackendCollectionArgs) ToGetBackendsBackendCollectionOutput() GetBackendsBackendCollectionOutput

func (GetBackendsBackendCollectionArgs) ToGetBackendsBackendCollectionOutputWithContext 

func (i GetBackendsBackendCollectionArgs) ToGetBackendsBackendCollectionOutputWithContext(ctx context.Context) GetBackendsBackendCollectionOutput

type GetBackendsBackendCollectionArray 

type GetBackendsBackendCollectionArray []GetBackendsBackendCollectionInput

func (GetBackendsBackendCollectionArray) ElementType 

func (GetBackendsBackendCollectionArray) ElementType() reflect.Type

func (GetBackendsBackendCollectionArray) ToGetBackendsBackendCollectionArrayOutput 

func (i GetBackendsBackendCollectionArray) ToGetBackendsBackendCollectionArrayOutput() GetBackendsBackendCollectionArrayOutput

func (GetBackendsBackendCollectionArray) ToGetBackendsBackendCollectionArrayOutputWithContext 

func (i GetBackendsBackendCollectionArray) ToGetBackendsBackendCollectionArrayOutputWithContext(ctx context.Context) GetBackendsBackendCollectionArrayOutput

type GetBackendsBackendCollectionArrayInput 

type GetBackendsBackendCollectionArrayInput interface {
	pulumi.Input

	ToGetBackendsBackendCollectionArrayOutput() GetBackendsBackendCollectionArrayOutput
	ToGetBackendsBackendCollectionArrayOutputWithContext(context.Context) GetBackendsBackendCollectionArrayOutput
}

GetBackendsBackendCollectionArrayInput is an input type that accepts GetBackendsBackendCollectionArray and GetBackendsBackendCollectionArrayOutput values. You can construct a concrete instance of `GetBackendsBackendCollectionArrayInput` via: 

GetBackendsBackendCollectionArray{ GetBackendsBackendCollectionArgs{...} }

type GetBackendsBackendCollectionArrayOutput 

type GetBackendsBackendCollectionArrayOutput struct{ *pulumi.OutputState }

func (GetBackendsBackendCollectionArrayOutput) ElementType 

func (GetBackendsBackendCollectionArrayOutput) ElementType() reflect.Type

func (GetBackendsBackendCollectionArrayOutput) Index 

func (o GetBackendsBackendCollectionArrayOutput) Index(i pulumi.IntInput) GetBackendsBackendCollectionOutput

func (GetBackendsBackendCollectionArrayOutput) ToGetBackendsBackendCollectionArrayOutput 

func (o GetBackendsBackendCollectionArrayOutput) ToGetBackendsBackendCollectionArrayOutput() GetBackendsBackendCollectionArrayOutput

func (GetBackendsBackendCollectionArrayOutput) ToGetBackendsBackendCollectionArrayOutputWithContext 

func (o GetBackendsBackendCollectionArrayOutput) ToGetBackendsBackendCollectionArrayOutputWithContext(ctx context.Context) GetBackendsBackendCollectionArrayOutput

type GetBackendsBackendCollectionInput 

type GetBackendsBackendCollectionInput interface {
	pulumi.Input

	ToGetBackendsBackendCollectionOutput() GetBackendsBackendCollectionOutput
	ToGetBackendsBackendCollectionOutputWithContext(context.Context) GetBackendsBackendCollectionOutput
}

GetBackendsBackendCollectionInput is an input type that accepts GetBackendsBackendCollectionArgs and GetBackendsBackendCollectionOutput values. You can construct a concrete instance of `GetBackendsBackendCollectionInput` via: 

GetBackendsBackendCollectionArgs{...}

type GetBackendsBackendCollectionItem 

type GetBackendsBackendCollectionItem struct {
	// The name of the backend set associated with the backend servers.  Example: `exampleBackendSet`
	BackendSetName string `pulumi:"backendSetName"`
	Id             string `pulumi:"id"`
	// The IP address of the backend server. Example: `10.0.0.3`
	IpAddress string `pulumi:"ipAddress"`
	// Whether the network load balancer should treat this server as a backup unit. If `true`, then the network load balancer forwards no ingress traffic to this backend server unless all other backend servers not marked as "isBackup" fail the health check policy.  Example: `false`
	IsBackup bool `pulumi:"isBackup"`
	// Whether the network load balancer should drain this server. Servers marked "isDrain" receive no incoming traffic.  Example: `false`
	IsDrain bool `pulumi:"isDrain"`
	// Whether the network load balancer should treat this server as offline. Offline servers receive no incoming traffic.  Example: `false`
	IsOffline bool `pulumi:"isOffline"`
	// A read-only field showing the IP address/IP OCID and port that uniquely identify this backend server in the backend set.  Example: `10.0.0.3:8080`, or `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>:443` or `10.0.0.3:0`
	Name string `pulumi:"name"`
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId string `pulumi:"networkLoadBalancerId"`
	// The communication port for the backend server.  Example: `8080`
	Port int `pulumi:"port"`
	// The IP OCID/Instance OCID associated with the backend server. Example: `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>`
	TargetId string `pulumi:"targetId"`
	// The network load balancing policy weight assigned to the server. Backend servers with a higher weight receive a larger proportion of incoming traffic. For example, a server weighted '3' receives three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/introducton.htm#Policies).  Example: `3`
	Weight int `pulumi:"weight"`
}

type GetBackendsBackendCollectionItemArgs 

type GetBackendsBackendCollectionItemArgs struct {
	// The name of the backend set associated with the backend servers.  Example: `exampleBackendSet`
	BackendSetName pulumi.StringInput `pulumi:"backendSetName"`
	Id             pulumi.StringInput `pulumi:"id"`
	// The IP address of the backend server. Example: `10.0.0.3`
	IpAddress pulumi.StringInput `pulumi:"ipAddress"`
	// Whether the network load balancer should treat this server as a backup unit. If `true`, then the network load balancer forwards no ingress traffic to this backend server unless all other backend servers not marked as "isBackup" fail the health check policy.  Example: `false`
	IsBackup pulumi.BoolInput `pulumi:"isBackup"`
	// Whether the network load balancer should drain this server. Servers marked "isDrain" receive no incoming traffic.  Example: `false`
	IsDrain pulumi.BoolInput `pulumi:"isDrain"`
	// Whether the network load balancer should treat this server as offline. Offline servers receive no incoming traffic.  Example: `false`
	IsOffline pulumi.BoolInput `pulumi:"isOffline"`
	// A read-only field showing the IP address/IP OCID and port that uniquely identify this backend server in the backend set.  Example: `10.0.0.3:8080`, or `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>:443` or `10.0.0.3:0`
	Name pulumi.StringInput `pulumi:"name"`
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId pulumi.StringInput `pulumi:"networkLoadBalancerId"`
	// The communication port for the backend server.  Example: `8080`
	Port pulumi.IntInput `pulumi:"port"`
	// The IP OCID/Instance OCID associated with the backend server. Example: `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>`
	TargetId pulumi.StringInput `pulumi:"targetId"`
	// The network load balancing policy weight assigned to the server. Backend servers with a higher weight receive a larger proportion of incoming traffic. For example, a server weighted '3' receives three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/introducton.htm#Policies).  Example: `3`
	Weight pulumi.IntInput `pulumi:"weight"`
}

func (GetBackendsBackendCollectionItemArgs) ElementType 

func (GetBackendsBackendCollectionItemArgs) ElementType() reflect.Type

func (GetBackendsBackendCollectionItemArgs) ToGetBackendsBackendCollectionItemOutput 

func (i GetBackendsBackendCollectionItemArgs) ToGetBackendsBackendCollectionItemOutput() GetBackendsBackendCollectionItemOutput

func (GetBackendsBackendCollectionItemArgs) ToGetBackendsBackendCollectionItemOutputWithContext 

func (i GetBackendsBackendCollectionItemArgs) ToGetBackendsBackendCollectionItemOutputWithContext(ctx context.Context) GetBackendsBackendCollectionItemOutput

type GetBackendsBackendCollectionItemArray 

type GetBackendsBackendCollectionItemArray []GetBackendsBackendCollectionItemInput

func (GetBackendsBackendCollectionItemArray) ElementType 

func (GetBackendsBackendCollectionItemArray) ElementType() reflect.Type

func (GetBackendsBackendCollectionItemArray) ToGetBackendsBackendCollectionItemArrayOutput 

func (i GetBackendsBackendCollectionItemArray) ToGetBackendsBackendCollectionItemArrayOutput() GetBackendsBackendCollectionItemArrayOutput

func (GetBackendsBackendCollectionItemArray) ToGetBackendsBackendCollectionItemArrayOutputWithContext 

func (i GetBackendsBackendCollectionItemArray) ToGetBackendsBackendCollectionItemArrayOutputWithContext(ctx context.Context) GetBackendsBackendCollectionItemArrayOutput

type GetBackendsBackendCollectionItemArrayInput 

type GetBackendsBackendCollectionItemArrayInput interface {
	pulumi.Input

	ToGetBackendsBackendCollectionItemArrayOutput() GetBackendsBackendCollectionItemArrayOutput
	ToGetBackendsBackendCollectionItemArrayOutputWithContext(context.Context) GetBackendsBackendCollectionItemArrayOutput
}

GetBackendsBackendCollectionItemArrayInput is an input type that accepts GetBackendsBackendCollectionItemArray and GetBackendsBackendCollectionItemArrayOutput values. You can construct a concrete instance of `GetBackendsBackendCollectionItemArrayInput` via: 

GetBackendsBackendCollectionItemArray{ GetBackendsBackendCollectionItemArgs{...} }

type GetBackendsBackendCollectionItemArrayOutput 

type GetBackendsBackendCollectionItemArrayOutput struct{ *pulumi.OutputState }

func (GetBackendsBackendCollectionItemArrayOutput) ElementType 

func (GetBackendsBackendCollectionItemArrayOutput) ElementType() reflect.Type

func (GetBackendsBackendCollectionItemArrayOutput) Index 

func (o GetBackendsBackendCollectionItemArrayOutput) Index(i pulumi.IntInput) GetBackendsBackendCollectionItemOutput

func (GetBackendsBackendCollectionItemArrayOutput) ToGetBackendsBackendCollectionItemArrayOutput 

func (o GetBackendsBackendCollectionItemArrayOutput) ToGetBackendsBackendCollectionItemArrayOutput() GetBackendsBackendCollectionItemArrayOutput

func (GetBackendsBackendCollectionItemArrayOutput) ToGetBackendsBackendCollectionItemArrayOutputWithContext 

func (o GetBackendsBackendCollectionItemArrayOutput) ToGetBackendsBackendCollectionItemArrayOutputWithContext(ctx context.Context) GetBackendsBackendCollectionItemArrayOutput

type GetBackendsBackendCollectionItemInput 

type GetBackendsBackendCollectionItemInput interface {
	pulumi.Input

	ToGetBackendsBackendCollectionItemOutput() GetBackendsBackendCollectionItemOutput
	ToGetBackendsBackendCollectionItemOutputWithContext(context.Context) GetBackendsBackendCollectionItemOutput
}

GetBackendsBackendCollectionItemInput is an input type that accepts GetBackendsBackendCollectionItemArgs and GetBackendsBackendCollectionItemOutput values. You can construct a concrete instance of `GetBackendsBackendCollectionItemInput` via: 

GetBackendsBackendCollectionItemArgs{...}

type GetBackendsBackendCollectionItemOutput 

type GetBackendsBackendCollectionItemOutput struct{ *pulumi.OutputState }

func (GetBackendsBackendCollectionItemOutput) BackendSetName 

func (o GetBackendsBackendCollectionItemOutput) BackendSetName() pulumi.StringOutput

The name of the backend set associated with the backend servers. Example: `exampleBackendSet`

func (GetBackendsBackendCollectionItemOutput) ElementType 

func (GetBackendsBackendCollectionItemOutput) ElementType() reflect.Type

func (GetBackendsBackendCollectionItemOutput) Id 

func (o GetBackendsBackendCollectionItemOutput) Id() pulumi.StringOutput

func (GetBackendsBackendCollectionItemOutput) IpAddress 

func (o GetBackendsBackendCollectionItemOutput) IpAddress() pulumi.StringOutput

The IP address of the backend server. Example: `10.0.0.3`

func (GetBackendsBackendCollectionItemOutput) IsBackup 

func (o GetBackendsBackendCollectionItemOutput) IsBackup() pulumi.BoolOutput

Whether the network load balancer should treat this server as a backup unit. If `true`, then the network load balancer forwards no ingress traffic to this backend server unless all other backend servers not marked as "isBackup" fail the health check policy. Example: `false`

func (GetBackendsBackendCollectionItemOutput) IsDrain 

func (o GetBackendsBackendCollectionItemOutput) IsDrain() pulumi.BoolOutput

Whether the network load balancer should drain this server. Servers marked "isDrain" receive no incoming traffic. Example: `false`

func (GetBackendsBackendCollectionItemOutput) IsOffline 

func (o GetBackendsBackendCollectionItemOutput) IsOffline() pulumi.BoolOutput

Whether the network load balancer should treat this server as offline. Offline servers receive no incoming traffic. Example: `false`

func (GetBackendsBackendCollectionItemOutput) Name 

func (o GetBackendsBackendCollectionItemOutput) Name() pulumi.StringOutput

A read-only field showing the IP address/IP OCID and port that uniquely identify this backend server in the backend set. Example: `10.0.0.3:8080`, or `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>:443` or `10.0.0.3:0`

func (GetBackendsBackendCollectionItemOutput) NetworkLoadBalancerId 

func (o GetBackendsBackendCollectionItemOutput) NetworkLoadBalancerId() pulumi.StringOutput

The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.

func (GetBackendsBackendCollectionItemOutput) Port 

func (o GetBackendsBackendCollectionItemOutput) Port() pulumi.IntOutput

The communication port for the backend server. Example: `8080`

func (GetBackendsBackendCollectionItemOutput) TargetId 

func (o GetBackendsBackendCollectionItemOutput) TargetId() pulumi.StringOutput

The IP OCID/Instance OCID associated with the backend server. Example: `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>`

func (GetBackendsBackendCollectionItemOutput) ToGetBackendsBackendCollectionItemOutput 

func (o GetBackendsBackendCollectionItemOutput) ToGetBackendsBackendCollectionItemOutput() GetBackendsBackendCollectionItemOutput

func (GetBackendsBackendCollectionItemOutput) ToGetBackendsBackendCollectionItemOutputWithContext 

func (o GetBackendsBackendCollectionItemOutput) ToGetBackendsBackendCollectionItemOutputWithContext(ctx context.Context) GetBackendsBackendCollectionItemOutput

func (GetBackendsBackendCollectionItemOutput) Weight 

func (o GetBackendsBackendCollectionItemOutput) Weight() pulumi.IntOutput

The network load balancing policy weight assigned to the server. Backend servers with a higher weight receive a larger proportion of incoming traffic. For example, a server weighted '3' receives three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/introducton.htm#Policies). Example: `3`

type GetBackendsBackendCollectionOutput 

type GetBackendsBackendCollectionOutput struct{ *pulumi.OutputState }

func (GetBackendsBackendCollectionOutput) ElementType 

func (GetBackendsBackendCollectionOutput) ElementType() reflect.Type

func (GetBackendsBackendCollectionOutput) Items 

func (o GetBackendsBackendCollectionOutput) Items() GetBackendsBackendCollectionItemArrayOutput

func (GetBackendsBackendCollectionOutput) ToGetBackendsBackendCollectionOutput 

func (o GetBackendsBackendCollectionOutput) ToGetBackendsBackendCollectionOutput() GetBackendsBackendCollectionOutput

func (GetBackendsBackendCollectionOutput) ToGetBackendsBackendCollectionOutputWithContext 

func (o GetBackendsBackendCollectionOutput) ToGetBackendsBackendCollectionOutputWithContext(ctx context.Context) GetBackendsBackendCollectionOutput

type GetBackendsFilter 

type GetBackendsFilter struct {
	// A read-only field showing the IP address/IP OCID and port that uniquely identify this backend server in the backend set.  Example: `10.0.0.3:8080`, or `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>:443` or `10.0.0.3:0`
	Name   string   `pulumi:"name"`
	Regex  *bool    `pulumi:"regex"`
	Values []string `pulumi:"values"`
}

type GetBackendsFilterArgs 

type GetBackendsFilterArgs struct {
	// A read-only field showing the IP address/IP OCID and port that uniquely identify this backend server in the backend set.  Example: `10.0.0.3:8080`, or `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>:443` or `10.0.0.3:0`
	Name   pulumi.StringInput      `pulumi:"name"`
	Regex  pulumi.BoolPtrInput     `pulumi:"regex"`
	Values pulumi.StringArrayInput `pulumi:"values"`
}

func (GetBackendsFilterArgs) ElementType 

func (GetBackendsFilterArgs) ElementType() reflect.Type

func (GetBackendsFilterArgs) ToGetBackendsFilterOutput 

func (i GetBackendsFilterArgs) ToGetBackendsFilterOutput() GetBackendsFilterOutput

func (GetBackendsFilterArgs) ToGetBackendsFilterOutputWithContext 

func (i GetBackendsFilterArgs) ToGetBackendsFilterOutputWithContext(ctx context.Context) GetBackendsFilterOutput

type GetBackendsFilterArray 

type GetBackendsFilterArray []GetBackendsFilterInput

func (GetBackendsFilterArray) ElementType 

func (GetBackendsFilterArray) ElementType() reflect.Type

func (GetBackendsFilterArray) ToGetBackendsFilterArrayOutput 

func (i GetBackendsFilterArray) ToGetBackendsFilterArrayOutput() GetBackendsFilterArrayOutput

func (GetBackendsFilterArray) ToGetBackendsFilterArrayOutputWithContext 

func (i GetBackendsFilterArray) ToGetBackendsFilterArrayOutputWithContext(ctx context.Context) GetBackendsFilterArrayOutput

type GetBackendsFilterArrayInput 

type GetBackendsFilterArrayInput interface {
	pulumi.Input

	ToGetBackendsFilterArrayOutput() GetBackendsFilterArrayOutput
	ToGetBackendsFilterArrayOutputWithContext(context.Context) GetBackendsFilterArrayOutput
}

GetBackendsFilterArrayInput is an input type that accepts GetBackendsFilterArray and GetBackendsFilterArrayOutput values. You can construct a concrete instance of `GetBackendsFilterArrayInput` via: 

GetBackendsFilterArray{ GetBackendsFilterArgs{...} }

type GetBackendsFilterArrayOutput 

type GetBackendsFilterArrayOutput struct{ *pulumi.OutputState }

func (GetBackendsFilterArrayOutput) ElementType 

func (GetBackendsFilterArrayOutput) ElementType() reflect.Type

func (GetBackendsFilterArrayOutput) Index 

func (o GetBackendsFilterArrayOutput) Index(i pulumi.IntInput) GetBackendsFilterOutput

func (GetBackendsFilterArrayOutput) ToGetBackendsFilterArrayOutput 

func (o GetBackendsFilterArrayOutput) ToGetBackendsFilterArrayOutput() GetBackendsFilterArrayOutput

func (GetBackendsFilterArrayOutput) ToGetBackendsFilterArrayOutputWithContext 

func (o GetBackendsFilterArrayOutput) ToGetBackendsFilterArrayOutputWithContext(ctx context.Context) GetBackendsFilterArrayOutput

type GetBackendsFilterInput 

type GetBackendsFilterInput interface {
	pulumi.Input

	ToGetBackendsFilterOutput() GetBackendsFilterOutput
	ToGetBackendsFilterOutputWithContext(context.Context) GetBackendsFilterOutput
}

GetBackendsFilterInput is an input type that accepts GetBackendsFilterArgs and GetBackendsFilterOutput values. You can construct a concrete instance of `GetBackendsFilterInput` via: 

GetBackendsFilterArgs{...}

type GetBackendsFilterOutput 

type GetBackendsFilterOutput struct{ *pulumi.OutputState }

func (GetBackendsFilterOutput) ElementType 

func (GetBackendsFilterOutput) ElementType() reflect.Type

func (GetBackendsFilterOutput) Name 

func (o GetBackendsFilterOutput) Name() pulumi.StringOutput

A read-only field showing the IP address/IP OCID and port that uniquely identify this backend server in the backend set. Example: `10.0.0.3:8080`, or `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>:443` or `10.0.0.3:0`

func (GetBackendsFilterOutput) Regex 

func (o GetBackendsFilterOutput) Regex() pulumi.BoolPtrOutput

func (GetBackendsFilterOutput) ToGetBackendsFilterOutput 

func (o GetBackendsFilterOutput) ToGetBackendsFilterOutput() GetBackendsFilterOutput

func (GetBackendsFilterOutput) ToGetBackendsFilterOutputWithContext 

func (o GetBackendsFilterOutput) ToGetBackendsFilterOutputWithContext(ctx context.Context) GetBackendsFilterOutput

func (GetBackendsFilterOutput) Values 

func (o GetBackendsFilterOutput) Values() pulumi.StringArrayOutput

type GetBackendsOutputArgs 

type GetBackendsOutputArgs struct {
	// The name of the backend set associated with the backend servers.  Example: `exampleBackendSet`
	BackendSetName pulumi.StringInput          `pulumi:"backendSetName"`
	Filters        GetBackendsFilterArrayInput `pulumi:"filters"`
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId pulumi.StringInput `pulumi:"networkLoadBalancerId"`
}

A collection of arguments for invoking getBackends.

func (GetBackendsOutputArgs) ElementType 

func (GetBackendsOutputArgs) ElementType() reflect.Type

type GetBackendsResult 

type GetBackendsResult struct {
	// The list of backend_collection.
	BackendCollections []GetBackendsBackendCollection `pulumi:"backendCollections"`
	BackendSetName     string                         `pulumi:"backendSetName"`
	Filters            []GetBackendsFilter            `pulumi:"filters"`
	// The provider-assigned unique ID for this managed resource.
	Id                    string `pulumi:"id"`
	NetworkLoadBalancerId string `pulumi:"networkLoadBalancerId"`
}

A collection of values returned by getBackends.

func GetBackends 

func GetBackends(ctx *pulumi.Context, args *GetBackendsArgs, opts ...pulumi.InvokeOption) (*GetBackendsResult, error)

This data source provides the list of Backends in Oracle Cloud Infrastructure Network Load Balancer service.

Lists the backend servers for a given network load balancer and backend set.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-oci/sdk/v2/go/oci/NetworkLoadBalancer"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := NetworkLoadBalancer.GetBackends(ctx, &networkloadbalancer.GetBackendsArgs{
			BackendSetName:        testBackendSet.Name,
			NetworkLoadBalancerId: testNetworkLoadBalancer.Id,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type GetBackendsResultOutput 

type GetBackendsResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getBackends.

func GetBackendsOutput 

func GetBackendsOutput(ctx *pulumi.Context, args GetBackendsOutputArgs, opts ...pulumi.InvokeOption) GetBackendsResultOutput

func (GetBackendsResultOutput) BackendCollections 

func (o GetBackendsResultOutput) BackendCollections() GetBackendsBackendCollectionArrayOutput

The list of backend_collection.

func (GetBackendsResultOutput) BackendSetName 

func (o GetBackendsResultOutput) BackendSetName() pulumi.StringOutput

func (GetBackendsResultOutput) ElementType 

func (GetBackendsResultOutput) ElementType() reflect.Type

func (GetBackendsResultOutput) Filters 

func (o GetBackendsResultOutput) Filters() GetBackendsFilterArrayOutput

func (GetBackendsResultOutput) Id 

func (o GetBackendsResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (GetBackendsResultOutput) NetworkLoadBalancerId 

func (o GetBackendsResultOutput) NetworkLoadBalancerId() pulumi.StringOutput

func (GetBackendsResultOutput) ToGetBackendsResultOutput 

func (o GetBackendsResultOutput) ToGetBackendsResultOutput() GetBackendsResultOutput

func (GetBackendsResultOutput) ToGetBackendsResultOutputWithContext 

func (o GetBackendsResultOutput) ToGetBackendsResultOutputWithContext(ctx context.Context) GetBackendsResultOutput

type GetListenersArgs 

type GetListenersArgs struct {
	Filters []GetListenersFilter `pulumi:"filters"`
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId string `pulumi:"networkLoadBalancerId"`
}

A collection of arguments for invoking getListeners.

type GetListenersFilter 

type GetListenersFilter struct {
	// A friendly name for the listener. It must be unique and it cannot be changed.  Example: `exampleListener`
	Name   string   `pulumi:"name"`
	Regex  *bool    `pulumi:"regex"`
	Values []string `pulumi:"values"`
}

type GetListenersFilterArgs 

type GetListenersFilterArgs struct {
	// A friendly name for the listener. It must be unique and it cannot be changed.  Example: `exampleListener`
	Name   pulumi.StringInput      `pulumi:"name"`
	Regex  pulumi.BoolPtrInput     `pulumi:"regex"`
	Values pulumi.StringArrayInput `pulumi:"values"`
}

func (GetListenersFilterArgs) ElementType 

func (GetListenersFilterArgs) ElementType() reflect.Type

func (GetListenersFilterArgs) ToGetListenersFilterOutput 

func (i GetListenersFilterArgs) ToGetListenersFilterOutput() GetListenersFilterOutput

func (GetListenersFilterArgs) ToGetListenersFilterOutputWithContext 

func (i GetListenersFilterArgs) ToGetListenersFilterOutputWithContext(ctx context.Context) GetListenersFilterOutput

type GetListenersFilterArray 

type GetListenersFilterArray []GetListenersFilterInput

func (GetListenersFilterArray) ElementType 

func (GetListenersFilterArray) ElementType() reflect.Type

func (GetListenersFilterArray) ToGetListenersFilterArrayOutput 

func (i GetListenersFilterArray) ToGetListenersFilterArrayOutput() GetListenersFilterArrayOutput

func (GetListenersFilterArray) ToGetListenersFilterArrayOutputWithContext 

func (i GetListenersFilterArray) ToGetListenersFilterArrayOutputWithContext(ctx context.Context) GetListenersFilterArrayOutput

type GetListenersFilterArrayInput 

type GetListenersFilterArrayInput interface {
	pulumi.Input

	ToGetListenersFilterArrayOutput() GetListenersFilterArrayOutput
	ToGetListenersFilterArrayOutputWithContext(context.Context) GetListenersFilterArrayOutput
}

GetListenersFilterArrayInput is an input type that accepts GetListenersFilterArray and GetListenersFilterArrayOutput values. You can construct a concrete instance of `GetListenersFilterArrayInput` via: 

GetListenersFilterArray{ GetListenersFilterArgs{...} }

type GetListenersFilterArrayOutput 

type GetListenersFilterArrayOutput struct{ *pulumi.OutputState }

func (GetListenersFilterArrayOutput) ElementType 

func (GetListenersFilterArrayOutput) ElementType() reflect.Type

func (GetListenersFilterArrayOutput) Index 

func (o GetListenersFilterArrayOutput) Index(i pulumi.IntInput) GetListenersFilterOutput

func (GetListenersFilterArrayOutput) ToGetListenersFilterArrayOutput 

func (o GetListenersFilterArrayOutput) ToGetListenersFilterArrayOutput() GetListenersFilterArrayOutput

func (GetListenersFilterArrayOutput) ToGetListenersFilterArrayOutputWithContext 

func (o GetListenersFilterArrayOutput) ToGetListenersFilterArrayOutputWithContext(ctx context.Context) GetListenersFilterArrayOutput

type GetListenersFilterInput 

type GetListenersFilterInput interface {
	pulumi.Input

	ToGetListenersFilterOutput() GetListenersFilterOutput
	ToGetListenersFilterOutputWithContext(context.Context) GetListenersFilterOutput
}

GetListenersFilterInput is an input type that accepts GetListenersFilterArgs and GetListenersFilterOutput values. You can construct a concrete instance of `GetListenersFilterInput` via: 

GetListenersFilterArgs{...}

type GetListenersFilterOutput 

type GetListenersFilterOutput struct{ *pulumi.OutputState }

func (GetListenersFilterOutput) ElementType 

func (GetListenersFilterOutput) ElementType() reflect.Type

func (GetListenersFilterOutput) Name 

func (o GetListenersFilterOutput) Name() pulumi.StringOutput

A friendly name for the listener. It must be unique and it cannot be changed. Example: `exampleListener`

func (GetListenersFilterOutput) Regex 

func (o GetListenersFilterOutput) Regex() pulumi.BoolPtrOutput

func (GetListenersFilterOutput) ToGetListenersFilterOutput 

func (o GetListenersFilterOutput) ToGetListenersFilterOutput() GetListenersFilterOutput

func (GetListenersFilterOutput) ToGetListenersFilterOutputWithContext 

func (o GetListenersFilterOutput) ToGetListenersFilterOutputWithContext(ctx context.Context) GetListenersFilterOutput

func (GetListenersFilterOutput) Values 

func (o GetListenersFilterOutput) Values() pulumi.StringArrayOutput

type GetListenersListenerCollection 

type GetListenersListenerCollection struct {
	Items []GetListenersListenerCollectionItem `pulumi:"items"`
}

type GetListenersListenerCollectionArgs 

type GetListenersListenerCollectionArgs struct {
	Items GetListenersListenerCollectionItemArrayInput `pulumi:"items"`
}

func (GetListenersListenerCollectionArgs) ElementType 

func (GetListenersListenerCollectionArgs) ElementType() reflect.Type

func (GetListenersListenerCollectionArgs) ToGetListenersListenerCollectionOutput 

func (i GetListenersListenerCollectionArgs) ToGetListenersListenerCollectionOutput() GetListenersListenerCollectionOutput

func (GetListenersListenerCollectionArgs) ToGetListenersListenerCollectionOutputWithContext 

func (i GetListenersListenerCollectionArgs) ToGetListenersListenerCollectionOutputWithContext(ctx context.Context) GetListenersListenerCollectionOutput

type GetListenersListenerCollectionArray 

type GetListenersListenerCollectionArray []GetListenersListenerCollectionInput

func (GetListenersListenerCollectionArray) ElementType 

func (GetListenersListenerCollectionArray) ElementType() reflect.Type

func (GetListenersListenerCollectionArray) ToGetListenersListenerCollectionArrayOutput 

func (i GetListenersListenerCollectionArray) ToGetListenersListenerCollectionArrayOutput() GetListenersListenerCollectionArrayOutput

func (GetListenersListenerCollectionArray) ToGetListenersListenerCollectionArrayOutputWithContext 

func (i GetListenersListenerCollectionArray) ToGetListenersListenerCollectionArrayOutputWithContext(ctx context.Context) GetListenersListenerCollectionArrayOutput

type GetListenersListenerCollectionArrayInput 

type GetListenersListenerCollectionArrayInput interface {
	pulumi.Input

	ToGetListenersListenerCollectionArrayOutput() GetListenersListenerCollectionArrayOutput
	ToGetListenersListenerCollectionArrayOutputWithContext(context.Context) GetListenersListenerCollectionArrayOutput
}

GetListenersListenerCollectionArrayInput is an input type that accepts GetListenersListenerCollectionArray and GetListenersListenerCollectionArrayOutput values. You can construct a concrete instance of `GetListenersListenerCollectionArrayInput` via: 

GetListenersListenerCollectionArray{ GetListenersListenerCollectionArgs{...} }

type GetListenersListenerCollectionArrayOutput 

type GetListenersListenerCollectionArrayOutput struct{ *pulumi.OutputState }

func (GetListenersListenerCollectionArrayOutput) ElementType 

func (GetListenersListenerCollectionArrayOutput) ElementType() reflect.Type

func (GetListenersListenerCollectionArrayOutput) Index 

func (o GetListenersListenerCollectionArrayOutput) Index(i pulumi.IntInput) GetListenersListenerCollectionOutput

func (GetListenersListenerCollectionArrayOutput) ToGetListenersListenerCollectionArrayOutput 

func (o GetListenersListenerCollectionArrayOutput) ToGetListenersListenerCollectionArrayOutput() GetListenersListenerCollectionArrayOutput

func (GetListenersListenerCollectionArrayOutput) ToGetListenersListenerCollectionArrayOutputWithContext 

func (o GetListenersListenerCollectionArrayOutput) ToGetListenersListenerCollectionArrayOutputWithContext(ctx context.Context) GetListenersListenerCollectionArrayOutput

type GetListenersListenerCollectionInput 

type GetListenersListenerCollectionInput interface {
	pulumi.Input

	ToGetListenersListenerCollectionOutput() GetListenersListenerCollectionOutput
	ToGetListenersListenerCollectionOutputWithContext(context.Context) GetListenersListenerCollectionOutput
}

GetListenersListenerCollectionInput is an input type that accepts GetListenersListenerCollectionArgs and GetListenersListenerCollectionOutput values. You can construct a concrete instance of `GetListenersListenerCollectionInput` via: 

GetListenersListenerCollectionArgs{...}

type GetListenersListenerCollectionItem 

type GetListenersListenerCollectionItem struct {
	// The name of the associated backend set.  Example: `exampleBackendSet`
	DefaultBackendSetName string `pulumi:"defaultBackendSetName"`
	Id                    string `pulumi:"id"`
	// IP version associated with the listener.
	IpVersion string `pulumi:"ipVersion"`
	// Property to enable/disable PPv2 feature for this listener.
	IsPpv2enabled bool `pulumi:"isPpv2enabled"`
	// A friendly name for the listener. It must be unique and it cannot be changed.  Example: `exampleListener`
	Name string `pulumi:"name"`
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId string `pulumi:"networkLoadBalancerId"`
	// The communication port for the listener.  Example: `80`
	Port int `pulumi:"port"`
	// The protocol on which the listener accepts connection requests. For public network load balancers, ANY protocol refers to TCP/UDP with the wildcard port. For private network load balancers, ANY protocol refers to TCP/UDP/ICMP (note that ICMP requires isPreserveSourceDestination to be set to true). "ListNetworkLoadBalancersProtocols" API is deprecated and it will not return the updated values. Use the allowed values for the protocol instead.  Example: `TCP`
	Protocol string `pulumi:"protocol"`
	// The duration for TCP idle timeout in seconds. Example: `300`
	TcpIdleTimeout int `pulumi:"tcpIdleTimeout"`
	// The duration for UDP idle timeout in seconds. Example: `120`
	UdpIdleTimeout int `pulumi:"udpIdleTimeout"`
}

type GetListenersListenerCollectionItemArgs 

type GetListenersListenerCollectionItemArgs struct {
	// The name of the associated backend set.  Example: `exampleBackendSet`
	DefaultBackendSetName pulumi.StringInput `pulumi:"defaultBackendSetName"`
	Id                    pulumi.StringInput `pulumi:"id"`
	// IP version associated with the listener.
	IpVersion pulumi.StringInput `pulumi:"ipVersion"`
	// Property to enable/disable PPv2 feature for this listener.
	IsPpv2enabled pulumi.BoolInput `pulumi:"isPpv2enabled"`
	// A friendly name for the listener. It must be unique and it cannot be changed.  Example: `exampleListener`
	Name pulumi.StringInput `pulumi:"name"`
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId pulumi.StringInput `pulumi:"networkLoadBalancerId"`
	// The communication port for the listener.  Example: `80`
	Port pulumi.IntInput `pulumi:"port"`
	// The protocol on which the listener accepts connection requests. For public network load balancers, ANY protocol refers to TCP/UDP with the wildcard port. For private network load balancers, ANY protocol refers to TCP/UDP/ICMP (note that ICMP requires isPreserveSourceDestination to be set to true). "ListNetworkLoadBalancersProtocols" API is deprecated and it will not return the updated values. Use the allowed values for the protocol instead.  Example: `TCP`
	Protocol pulumi.StringInput `pulumi:"protocol"`
	// The duration for TCP idle timeout in seconds. Example: `300`
	TcpIdleTimeout pulumi.IntInput `pulumi:"tcpIdleTimeout"`
	// The duration for UDP idle timeout in seconds. Example: `120`
	UdpIdleTimeout pulumi.IntInput `pulumi:"udpIdleTimeout"`
}

func (GetListenersListenerCollectionItemArgs) ElementType 

func (GetListenersListenerCollectionItemArgs) ElementType() reflect.Type

func (GetListenersListenerCollectionItemArgs) ToGetListenersListenerCollectionItemOutput 

func (i GetListenersListenerCollectionItemArgs) ToGetListenersListenerCollectionItemOutput() GetListenersListenerCollectionItemOutput

func (GetListenersListenerCollectionItemArgs) ToGetListenersListenerCollectionItemOutputWithContext 

func (i GetListenersListenerCollectionItemArgs) ToGetListenersListenerCollectionItemOutputWithContext(ctx context.Context) GetListenersListenerCollectionItemOutput

type GetListenersListenerCollectionItemArray 

type GetListenersListenerCollectionItemArray []GetListenersListenerCollectionItemInput

func (GetListenersListenerCollectionItemArray) ElementType 

func (GetListenersListenerCollectionItemArray) ElementType() reflect.Type

func (GetListenersListenerCollectionItemArray) ToGetListenersListenerCollectionItemArrayOutput 

func (i GetListenersListenerCollectionItemArray) ToGetListenersListenerCollectionItemArrayOutput() GetListenersListenerCollectionItemArrayOutput

func (GetListenersListenerCollectionItemArray) ToGetListenersListenerCollectionItemArrayOutputWithContext 

func (i GetListenersListenerCollectionItemArray) ToGetListenersListenerCollectionItemArrayOutputWithContext(ctx context.Context) GetListenersListenerCollectionItemArrayOutput

type GetListenersListenerCollectionItemArrayInput 

type GetListenersListenerCollectionItemArrayInput interface {
	pulumi.Input

	ToGetListenersListenerCollectionItemArrayOutput() GetListenersListenerCollectionItemArrayOutput
	ToGetListenersListenerCollectionItemArrayOutputWithContext(context.Context) GetListenersListenerCollectionItemArrayOutput
}

GetListenersListenerCollectionItemArrayInput is an input type that accepts GetListenersListenerCollectionItemArray and GetListenersListenerCollectionItemArrayOutput values. You can construct a concrete instance of `GetListenersListenerCollectionItemArrayInput` via: 

GetListenersListenerCollectionItemArray{ GetListenersListenerCollectionItemArgs{...} }

type GetListenersListenerCollectionItemArrayOutput 

type GetListenersListenerCollectionItemArrayOutput struct{ *pulumi.OutputState }

func (GetListenersListenerCollectionItemArrayOutput) ElementType 

func (GetListenersListenerCollectionItemArrayOutput) ElementType() reflect.Type

func (GetListenersListenerCollectionItemArrayOutput) Index 

func (o GetListenersListenerCollectionItemArrayOutput) Index(i pulumi.IntInput) GetListenersListenerCollectionItemOutput

func (GetListenersListenerCollectionItemArrayOutput) ToGetListenersListenerCollectionItemArrayOutput 

func (o GetListenersListenerCollectionItemArrayOutput) ToGetListenersListenerCollectionItemArrayOutput() GetListenersListenerCollectionItemArrayOutput

func (GetListenersListenerCollectionItemArrayOutput) ToGetListenersListenerCollectionItemArrayOutputWithContext 

func (o GetListenersListenerCollectionItemArrayOutput) ToGetListenersListenerCollectionItemArrayOutputWithContext(ctx context.Context) GetListenersListenerCollectionItemArrayOutput

type GetListenersListenerCollectionItemInput 

type GetListenersListenerCollectionItemInput interface {
	pulumi.Input

	ToGetListenersListenerCollectionItemOutput() GetListenersListenerCollectionItemOutput
	ToGetListenersListenerCollectionItemOutputWithContext(context.Context) GetListenersListenerCollectionItemOutput
}

GetListenersListenerCollectionItemInput is an input type that accepts GetListenersListenerCollectionItemArgs and GetListenersListenerCollectionItemOutput values. You can construct a concrete instance of `GetListenersListenerCollectionItemInput` via: 

GetListenersListenerCollectionItemArgs{...}

type GetListenersListenerCollectionItemOutput 

type GetListenersListenerCollectionItemOutput struct{ *pulumi.OutputState }

func (GetListenersListenerCollectionItemOutput) DefaultBackendSetName 

func (o GetListenersListenerCollectionItemOutput) DefaultBackendSetName() pulumi.StringOutput

The name of the associated backend set. Example: `exampleBackendSet`

func (GetListenersListenerCollectionItemOutput) ElementType 

func (GetListenersListenerCollectionItemOutput) ElementType() reflect.Type

func (GetListenersListenerCollectionItemOutput) Id 

func (o GetListenersListenerCollectionItemOutput) Id() pulumi.StringOutput

func (GetListenersListenerCollectionItemOutput) IpVersion 

func (o GetListenersListenerCollectionItemOutput) IpVersion() pulumi.StringOutput

IP version associated with the listener.

func (GetListenersListenerCollectionItemOutput) IsPpv2enabled 

func (o GetListenersListenerCollectionItemOutput) IsPpv2enabled() pulumi.BoolOutput

Property to enable/disable PPv2 feature for this listener.

func (GetListenersListenerCollectionItemOutput) Name 

func (o GetListenersListenerCollectionItemOutput) Name() pulumi.StringOutput

A friendly name for the listener. It must be unique and it cannot be changed. Example: `exampleListener`

func (GetListenersListenerCollectionItemOutput) NetworkLoadBalancerId 

func (o GetListenersListenerCollectionItemOutput) NetworkLoadBalancerId() pulumi.StringOutput

The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.

func (GetListenersListenerCollectionItemOutput) Port 

func (o GetListenersListenerCollectionItemOutput) Port() pulumi.IntOutput

The communication port for the listener. Example: `80`

func (GetListenersListenerCollectionItemOutput) Protocol 

func (o GetListenersListenerCollectionItemOutput) Protocol() pulumi.StringOutput

The protocol on which the listener accepts connection requests. For public network load balancers, ANY protocol refers to TCP/UDP with the wildcard port. For private network load balancers, ANY protocol refers to TCP/UDP/ICMP (note that ICMP requires isPreserveSourceDestination to be set to true). "ListNetworkLoadBalancersProtocols" API is deprecated and it will not return the updated values. Use the allowed values for the protocol instead. Example: `TCP`

func (GetListenersListenerCollectionItemOutput) TcpIdleTimeout added in v2.7.0 

func (o GetListenersListenerCollectionItemOutput) TcpIdleTimeout() pulumi.IntOutput

The duration for TCP idle timeout in seconds. Example: `300`

func (GetListenersListenerCollectionItemOutput) ToGetListenersListenerCollectionItemOutput 

func (o GetListenersListenerCollectionItemOutput) ToGetListenersListenerCollectionItemOutput() GetListenersListenerCollectionItemOutput

func (GetListenersListenerCollectionItemOutput) ToGetListenersListenerCollectionItemOutputWithContext 

func (o GetListenersListenerCollectionItemOutput) ToGetListenersListenerCollectionItemOutputWithContext(ctx context.Context) GetListenersListenerCollectionItemOutput

func (GetListenersListenerCollectionItemOutput) UdpIdleTimeout added in v2.7.0 

func (o GetListenersListenerCollectionItemOutput) UdpIdleTimeout() pulumi.IntOutput

The duration for UDP idle timeout in seconds. Example: `120`

type GetListenersListenerCollectionOutput 

type GetListenersListenerCollectionOutput struct{ *pulumi.OutputState }

func (GetListenersListenerCollectionOutput) ElementType 

func (GetListenersListenerCollectionOutput) ElementType() reflect.Type

func (GetListenersListenerCollectionOutput) Items 

func (o GetListenersListenerCollectionOutput) Items() GetListenersListenerCollectionItemArrayOutput

func (GetListenersListenerCollectionOutput) ToGetListenersListenerCollectionOutput 

func (o GetListenersListenerCollectionOutput) ToGetListenersListenerCollectionOutput() GetListenersListenerCollectionOutput

func (GetListenersListenerCollectionOutput) ToGetListenersListenerCollectionOutputWithContext 

func (o GetListenersListenerCollectionOutput) ToGetListenersListenerCollectionOutputWithContext(ctx context.Context) GetListenersListenerCollectionOutput

type GetListenersOutputArgs 

type GetListenersOutputArgs struct {
	Filters GetListenersFilterArrayInput `pulumi:"filters"`
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId pulumi.StringInput `pulumi:"networkLoadBalancerId"`
}

A collection of arguments for invoking getListeners.

func (GetListenersOutputArgs) ElementType 

func (GetListenersOutputArgs) ElementType() reflect.Type

type GetListenersResult 

type GetListenersResult struct {
	Filters []GetListenersFilter `pulumi:"filters"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// The list of listener_collection.
	ListenerCollections   []GetListenersListenerCollection `pulumi:"listenerCollections"`
	NetworkLoadBalancerId string                           `pulumi:"networkLoadBalancerId"`
}

A collection of values returned by getListeners.

func GetListeners 

func GetListeners(ctx *pulumi.Context, args *GetListenersArgs, opts ...pulumi.InvokeOption) (*GetListenersResult, error)

This data source provides the list of Listeners in Oracle Cloud Infrastructure Network Load Balancer service.

Lists all listeners associated with a given network load balancer.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-oci/sdk/v2/go/oci/NetworkLoadBalancer"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := NetworkLoadBalancer.GetListeners(ctx, &networkloadbalancer.GetListenersArgs{
			NetworkLoadBalancerId: testNetworkLoadBalancer.Id,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type GetListenersResultOutput 

type GetListenersResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getListeners.

func GetListenersOutput 

func GetListenersOutput(ctx *pulumi.Context, args GetListenersOutputArgs, opts ...pulumi.InvokeOption) GetListenersResultOutput

func (GetListenersResultOutput) ElementType 

func (GetListenersResultOutput) ElementType() reflect.Type

func (GetListenersResultOutput) Filters 

func (o GetListenersResultOutput) Filters() GetListenersFilterArrayOutput

func (GetListenersResultOutput) Id 

func (o GetListenersResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (GetListenersResultOutput) ListenerCollections 

func (o GetListenersResultOutput) ListenerCollections() GetListenersListenerCollectionArrayOutput

The list of listener_collection.

func (GetListenersResultOutput) NetworkLoadBalancerId 

func (o GetListenersResultOutput) NetworkLoadBalancerId() pulumi.StringOutput

func (GetListenersResultOutput) ToGetListenersResultOutput 

func (o GetListenersResultOutput) ToGetListenersResultOutput() GetListenersResultOutput

func (GetListenersResultOutput) ToGetListenersResultOutputWithContext 

func (o GetListenersResultOutput) ToGetListenersResultOutputWithContext(ctx context.Context) GetListenersResultOutput

type GetNetworkLoadBalancerHealthArgs 

type GetNetworkLoadBalancerHealthArgs struct {
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId string `pulumi:"networkLoadBalancerId"`
}

A collection of arguments for invoking getNetworkLoadBalancerHealth.

type GetNetworkLoadBalancerHealthOutputArgs 

type GetNetworkLoadBalancerHealthOutputArgs struct {
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId pulumi.StringInput `pulumi:"networkLoadBalancerId"`
}

A collection of arguments for invoking getNetworkLoadBalancerHealth.

func (GetNetworkLoadBalancerHealthOutputArgs) ElementType 

func (GetNetworkLoadBalancerHealthOutputArgs) ElementType() reflect.Type

type GetNetworkLoadBalancerHealthResult 

type GetNetworkLoadBalancerHealthResult struct {
	// A list of backend sets that are currently in the `CRITICAL` health state. The list identifies each backend set by the user-friendly name you assigned when you created the backend set.  Example: `exampleBackendSet`
	CriticalStateBackendSetNames []string `pulumi:"criticalStateBackendSetNames"`
	// The provider-assigned unique ID for this managed resource.
	Id                    string `pulumi:"id"`
	NetworkLoadBalancerId string `pulumi:"networkLoadBalancerId"`
	// The overall health status of the network load balancer.
	// *  **OK:** All backend sets associated with the network load balancer return a status of `OK`.
	// *  **WARNING:** At least one of the backend sets associated with the network load balancer returns a status of `WARNING`, no backend sets return a status of `CRITICAL`, and the network load balancer life cycle state is `ACTIVE`.
	// *  **CRITICAL:** One or more of the backend sets associated with the network load balancer return a status of `CRITICAL`.
	// *  **UNKNOWN:** If any one of the following conditions is true:
	// *  The network load balancer life cycle state is not `ACTIVE`.
	// *  No backend sets are defined for the network load balancer.
	// *  More than half of the backend sets associated with the network load balancer return a status of `UNKNOWN`, none of the backend sets return a status of `WARNING` or `CRITICAL`, and the network load balancer life cycle state is `ACTIVE`.
	// *  The system could not retrieve metrics for any reason.
	Status string `pulumi:"status"`
	// The total number of backend sets associated with this network load balancer.  Example: `4`
	TotalBackendSetCount int `pulumi:"totalBackendSetCount"`
	// A list of backend sets that are currently in the `UNKNOWN` health state. The list identifies each backend set by the user-friendly name you assigned when you created the backend set.  Example: `exampleBackendSet2`
	UnknownStateBackendSetNames []string `pulumi:"unknownStateBackendSetNames"`
	// A list of backend sets that are currently in the `WARNING` health state. The list identifies each backend set by the user-friendly name you assigned when you created the backend set.  Example: `exampleBackendSet3`
	WarningStateBackendSetNames []string `pulumi:"warningStateBackendSetNames"`
}

A collection of values returned by getNetworkLoadBalancerHealth.

func GetNetworkLoadBalancerHealth 

func GetNetworkLoadBalancerHealth(ctx *pulumi.Context, args *GetNetworkLoadBalancerHealthArgs, opts ...pulumi.InvokeOption) (*GetNetworkLoadBalancerHealthResult, error)

This data source provides details about a specific Network Load Balancer Health resource in Oracle Cloud Infrastructure Network Load Balancer service.

Retrieves the health status for the specified network load balancer.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-oci/sdk/v2/go/oci/NetworkLoadBalancer"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := NetworkLoadBalancer.GetNetworkLoadBalancerHealth(ctx, &networkloadbalancer.GetNetworkLoadBalancerHealthArgs{
			NetworkLoadBalancerId: testNetworkLoadBalancer.Id,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type GetNetworkLoadBalancerHealthResultOutput 

type GetNetworkLoadBalancerHealthResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getNetworkLoadBalancerHealth.

func GetNetworkLoadBalancerHealthOutput 

func GetNetworkLoadBalancerHealthOutput(ctx *pulumi.Context, args GetNetworkLoadBalancerHealthOutputArgs, opts ...pulumi.InvokeOption) GetNetworkLoadBalancerHealthResultOutput

func (GetNetworkLoadBalancerHealthResultOutput) CriticalStateBackendSetNames 

func (o GetNetworkLoadBalancerHealthResultOutput) CriticalStateBackendSetNames() pulumi.StringArrayOutput

A list of backend sets that are currently in the `CRITICAL` health state. The list identifies each backend set by the user-friendly name you assigned when you created the backend set. Example: `exampleBackendSet`

func (GetNetworkLoadBalancerHealthResultOutput) ElementType 

func (GetNetworkLoadBalancerHealthResultOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancerHealthResultOutput) Id 

func (o GetNetworkLoadBalancerHealthResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (GetNetworkLoadBalancerHealthResultOutput) NetworkLoadBalancerId 

func (o GetNetworkLoadBalancerHealthResultOutput) NetworkLoadBalancerId() pulumi.StringOutput

func (GetNetworkLoadBalancerHealthResultOutput) Status 

func (o GetNetworkLoadBalancerHealthResultOutput) Status() pulumi.StringOutput

The overall health status of the network load balancer. * **OK:** All backend sets associated with the network load balancer return a status of `OK`. * **WARNING:** At least one of the backend sets associated with the network load balancer returns a status of `WARNING`, no backend sets return a status of `CRITICAL`, and the network load balancer life cycle state is `ACTIVE`. * **CRITICAL:** One or more of the backend sets associated with the network load balancer return a status of `CRITICAL`. * **UNKNOWN:** If any one of the following conditions is true: * The network load balancer life cycle state is not `ACTIVE`. * No backend sets are defined for the network load balancer. * More than half of the backend sets associated with the network load balancer return a status of `UNKNOWN`, none of the backend sets return a status of `WARNING` or `CRITICAL`, and the network load balancer life cycle state is `ACTIVE`. * The system could not retrieve metrics for any reason.

func (GetNetworkLoadBalancerHealthResultOutput) ToGetNetworkLoadBalancerHealthResultOutput 

func (o GetNetworkLoadBalancerHealthResultOutput) ToGetNetworkLoadBalancerHealthResultOutput() GetNetworkLoadBalancerHealthResultOutput

func (GetNetworkLoadBalancerHealthResultOutput) ToGetNetworkLoadBalancerHealthResultOutputWithContext 

func (o GetNetworkLoadBalancerHealthResultOutput) ToGetNetworkLoadBalancerHealthResultOutputWithContext(ctx context.Context) GetNetworkLoadBalancerHealthResultOutput

func (GetNetworkLoadBalancerHealthResultOutput) TotalBackendSetCount 

func (o GetNetworkLoadBalancerHealthResultOutput) TotalBackendSetCount() pulumi.IntOutput

The total number of backend sets associated with this network load balancer. Example: `4`

func (GetNetworkLoadBalancerHealthResultOutput) UnknownStateBackendSetNames 

func (o GetNetworkLoadBalancerHealthResultOutput) UnknownStateBackendSetNames() pulumi.StringArrayOutput

A list of backend sets that are currently in the `UNKNOWN` health state. The list identifies each backend set by the user-friendly name you assigned when you created the backend set. Example: `exampleBackendSet2`

func (GetNetworkLoadBalancerHealthResultOutput) WarningStateBackendSetNames 

func (o GetNetworkLoadBalancerHealthResultOutput) WarningStateBackendSetNames() pulumi.StringArrayOutput

A list of backend sets that are currently in the `WARNING` health state. The list identifies each backend set by the user-friendly name you assigned when you created the backend set. Example: `exampleBackendSet3`

type GetNetworkLoadBalancerIpAddress 

type GetNetworkLoadBalancerIpAddress struct {
	// An IP address.  Example: `192.168.0.3`
	IpAddress string `pulumi:"ipAddress"`
	// IP version associated with the listener.
	IpVersion string `pulumi:"ipVersion"`
	// Whether the IP address is public or private.
	IsPublic bool `pulumi:"isPublic"`
	// An object representing a reserved IP address to be attached or that is already attached to a network load balancer.
	ReservedIps []GetNetworkLoadBalancerIpAddressReservedIp `pulumi:"reservedIps"`
}

type GetNetworkLoadBalancerIpAddressArgs 

type GetNetworkLoadBalancerIpAddressArgs struct {
	// An IP address.  Example: `192.168.0.3`
	IpAddress pulumi.StringInput `pulumi:"ipAddress"`
	// IP version associated with the listener.
	IpVersion pulumi.StringInput `pulumi:"ipVersion"`
	// Whether the IP address is public or private.
	IsPublic pulumi.BoolInput `pulumi:"isPublic"`
	// An object representing a reserved IP address to be attached or that is already attached to a network load balancer.
	ReservedIps GetNetworkLoadBalancerIpAddressReservedIpArrayInput `pulumi:"reservedIps"`
}

func (GetNetworkLoadBalancerIpAddressArgs) ElementType 

func (GetNetworkLoadBalancerIpAddressArgs) ElementType() reflect.Type

func (GetNetworkLoadBalancerIpAddressArgs) ToGetNetworkLoadBalancerIpAddressOutput 

func (i GetNetworkLoadBalancerIpAddressArgs) ToGetNetworkLoadBalancerIpAddressOutput() GetNetworkLoadBalancerIpAddressOutput

func (GetNetworkLoadBalancerIpAddressArgs) ToGetNetworkLoadBalancerIpAddressOutputWithContext 

func (i GetNetworkLoadBalancerIpAddressArgs) ToGetNetworkLoadBalancerIpAddressOutputWithContext(ctx context.Context) GetNetworkLoadBalancerIpAddressOutput

type GetNetworkLoadBalancerIpAddressArray 

type GetNetworkLoadBalancerIpAddressArray []GetNetworkLoadBalancerIpAddressInput

func (GetNetworkLoadBalancerIpAddressArray) ElementType 

func (GetNetworkLoadBalancerIpAddressArray) ElementType() reflect.Type

func (GetNetworkLoadBalancerIpAddressArray) ToGetNetworkLoadBalancerIpAddressArrayOutput 

func (i GetNetworkLoadBalancerIpAddressArray) ToGetNetworkLoadBalancerIpAddressArrayOutput() GetNetworkLoadBalancerIpAddressArrayOutput

func (GetNetworkLoadBalancerIpAddressArray) ToGetNetworkLoadBalancerIpAddressArrayOutputWithContext 

func (i GetNetworkLoadBalancerIpAddressArray) ToGetNetworkLoadBalancerIpAddressArrayOutputWithContext(ctx context.Context) GetNetworkLoadBalancerIpAddressArrayOutput

type GetNetworkLoadBalancerIpAddressArrayInput 

type GetNetworkLoadBalancerIpAddressArrayInput interface {
	pulumi.Input

	ToGetNetworkLoadBalancerIpAddressArrayOutput() GetNetworkLoadBalancerIpAddressArrayOutput
	ToGetNetworkLoadBalancerIpAddressArrayOutputWithContext(context.Context) GetNetworkLoadBalancerIpAddressArrayOutput
}

GetNetworkLoadBalancerIpAddressArrayInput is an input type that accepts GetNetworkLoadBalancerIpAddressArray and GetNetworkLoadBalancerIpAddressArrayOutput values. You can construct a concrete instance of `GetNetworkLoadBalancerIpAddressArrayInput` via: 

GetNetworkLoadBalancerIpAddressArray{ GetNetworkLoadBalancerIpAddressArgs{...} }

type GetNetworkLoadBalancerIpAddressArrayOutput 

type GetNetworkLoadBalancerIpAddressArrayOutput struct{ *pulumi.OutputState }

func (GetNetworkLoadBalancerIpAddressArrayOutput) ElementType 

func (GetNetworkLoadBalancerIpAddressArrayOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancerIpAddressArrayOutput) Index 

func (o GetNetworkLoadBalancerIpAddressArrayOutput) Index(i pulumi.IntInput) GetNetworkLoadBalancerIpAddressOutput

func (GetNetworkLoadBalancerIpAddressArrayOutput) ToGetNetworkLoadBalancerIpAddressArrayOutput 

func (o GetNetworkLoadBalancerIpAddressArrayOutput) ToGetNetworkLoadBalancerIpAddressArrayOutput() GetNetworkLoadBalancerIpAddressArrayOutput

func (GetNetworkLoadBalancerIpAddressArrayOutput) ToGetNetworkLoadBalancerIpAddressArrayOutputWithContext 

func (o GetNetworkLoadBalancerIpAddressArrayOutput) ToGetNetworkLoadBalancerIpAddressArrayOutputWithContext(ctx context.Context) GetNetworkLoadBalancerIpAddressArrayOutput

type GetNetworkLoadBalancerIpAddressInput 

type GetNetworkLoadBalancerIpAddressInput interface {
	pulumi.Input

	ToGetNetworkLoadBalancerIpAddressOutput() GetNetworkLoadBalancerIpAddressOutput
	ToGetNetworkLoadBalancerIpAddressOutputWithContext(context.Context) GetNetworkLoadBalancerIpAddressOutput
}

GetNetworkLoadBalancerIpAddressInput is an input type that accepts GetNetworkLoadBalancerIpAddressArgs and GetNetworkLoadBalancerIpAddressOutput values. You can construct a concrete instance of `GetNetworkLoadBalancerIpAddressInput` via: 

GetNetworkLoadBalancerIpAddressArgs{...}

type GetNetworkLoadBalancerIpAddressOutput 

type GetNetworkLoadBalancerIpAddressOutput struct{ *pulumi.OutputState }

func (GetNetworkLoadBalancerIpAddressOutput) ElementType 

func (GetNetworkLoadBalancerIpAddressOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancerIpAddressOutput) IpAddress 

func (o GetNetworkLoadBalancerIpAddressOutput) IpAddress() pulumi.StringOutput

An IP address. Example: `192.168.0.3`

func (GetNetworkLoadBalancerIpAddressOutput) IpVersion 

func (o GetNetworkLoadBalancerIpAddressOutput) IpVersion() pulumi.StringOutput

IP version associated with the listener.

func (GetNetworkLoadBalancerIpAddressOutput) IsPublic 

func (o GetNetworkLoadBalancerIpAddressOutput) IsPublic() pulumi.BoolOutput

Whether the IP address is public or private.

func (GetNetworkLoadBalancerIpAddressOutput) ReservedIps 

func (o GetNetworkLoadBalancerIpAddressOutput) ReservedIps() GetNetworkLoadBalancerIpAddressReservedIpArrayOutput

An object representing a reserved IP address to be attached or that is already attached to a network load balancer.

func (GetNetworkLoadBalancerIpAddressOutput) ToGetNetworkLoadBalancerIpAddressOutput 

func (o GetNetworkLoadBalancerIpAddressOutput) ToGetNetworkLoadBalancerIpAddressOutput() GetNetworkLoadBalancerIpAddressOutput

func (GetNetworkLoadBalancerIpAddressOutput) ToGetNetworkLoadBalancerIpAddressOutputWithContext 

func (o GetNetworkLoadBalancerIpAddressOutput) ToGetNetworkLoadBalancerIpAddressOutputWithContext(ctx context.Context) GetNetworkLoadBalancerIpAddressOutput

type GetNetworkLoadBalancerIpAddressReservedIp 

type GetNetworkLoadBalancerIpAddressReservedIp struct {
	// OCID of the reserved public IP address created with the virtual cloud network.
	Id string `pulumi:"id"`
}

type GetNetworkLoadBalancerIpAddressReservedIpArgs 

type GetNetworkLoadBalancerIpAddressReservedIpArgs struct {
	// OCID of the reserved public IP address created with the virtual cloud network.
	Id pulumi.StringInput `pulumi:"id"`
}

func (GetNetworkLoadBalancerIpAddressReservedIpArgs) ElementType 

func (GetNetworkLoadBalancerIpAddressReservedIpArgs) ElementType() reflect.Type

func (GetNetworkLoadBalancerIpAddressReservedIpArgs) ToGetNetworkLoadBalancerIpAddressReservedIpOutput 

func (i GetNetworkLoadBalancerIpAddressReservedIpArgs) ToGetNetworkLoadBalancerIpAddressReservedIpOutput() GetNetworkLoadBalancerIpAddressReservedIpOutput

func (GetNetworkLoadBalancerIpAddressReservedIpArgs) ToGetNetworkLoadBalancerIpAddressReservedIpOutputWithContext 

func (i GetNetworkLoadBalancerIpAddressReservedIpArgs) ToGetNetworkLoadBalancerIpAddressReservedIpOutputWithContext(ctx context.Context) GetNetworkLoadBalancerIpAddressReservedIpOutput

type GetNetworkLoadBalancerIpAddressReservedIpArray 

type GetNetworkLoadBalancerIpAddressReservedIpArray []GetNetworkLoadBalancerIpAddressReservedIpInput

func (GetNetworkLoadBalancerIpAddressReservedIpArray) ElementType 

func (GetNetworkLoadBalancerIpAddressReservedIpArray) ElementType() reflect.Type

func (GetNetworkLoadBalancerIpAddressReservedIpArray) ToGetNetworkLoadBalancerIpAddressReservedIpArrayOutput 

func (i GetNetworkLoadBalancerIpAddressReservedIpArray) ToGetNetworkLoadBalancerIpAddressReservedIpArrayOutput() GetNetworkLoadBalancerIpAddressReservedIpArrayOutput

func (GetNetworkLoadBalancerIpAddressReservedIpArray) ToGetNetworkLoadBalancerIpAddressReservedIpArrayOutputWithContext 

func (i GetNetworkLoadBalancerIpAddressReservedIpArray) ToGetNetworkLoadBalancerIpAddressReservedIpArrayOutputWithContext(ctx context.Context) GetNetworkLoadBalancerIpAddressReservedIpArrayOutput

type GetNetworkLoadBalancerIpAddressReservedIpArrayInput 

type GetNetworkLoadBalancerIpAddressReservedIpArrayInput interface {
	pulumi.Input

	ToGetNetworkLoadBalancerIpAddressReservedIpArrayOutput() GetNetworkLoadBalancerIpAddressReservedIpArrayOutput
	ToGetNetworkLoadBalancerIpAddressReservedIpArrayOutputWithContext(context.Context) GetNetworkLoadBalancerIpAddressReservedIpArrayOutput
}

GetNetworkLoadBalancerIpAddressReservedIpArrayInput is an input type that accepts GetNetworkLoadBalancerIpAddressReservedIpArray and GetNetworkLoadBalancerIpAddressReservedIpArrayOutput values. You can construct a concrete instance of `GetNetworkLoadBalancerIpAddressReservedIpArrayInput` via: 

GetNetworkLoadBalancerIpAddressReservedIpArray{ GetNetworkLoadBalancerIpAddressReservedIpArgs{...} }

type GetNetworkLoadBalancerIpAddressReservedIpArrayOutput 

type GetNetworkLoadBalancerIpAddressReservedIpArrayOutput struct{ *pulumi.OutputState }

func (GetNetworkLoadBalancerIpAddressReservedIpArrayOutput) ElementType 

func (GetNetworkLoadBalancerIpAddressReservedIpArrayOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancerIpAddressReservedIpArrayOutput) Index 

func (o GetNetworkLoadBalancerIpAddressReservedIpArrayOutput) Index(i pulumi.IntInput) GetNetworkLoadBalancerIpAddressReservedIpOutput

func (GetNetworkLoadBalancerIpAddressReservedIpArrayOutput) ToGetNetworkLoadBalancerIpAddressReservedIpArrayOutput 

func (o GetNetworkLoadBalancerIpAddressReservedIpArrayOutput) ToGetNetworkLoadBalancerIpAddressReservedIpArrayOutput() GetNetworkLoadBalancerIpAddressReservedIpArrayOutput

func (GetNetworkLoadBalancerIpAddressReservedIpArrayOutput) ToGetNetworkLoadBalancerIpAddressReservedIpArrayOutputWithContext 

func (o GetNetworkLoadBalancerIpAddressReservedIpArrayOutput) ToGetNetworkLoadBalancerIpAddressReservedIpArrayOutputWithContext(ctx context.Context) GetNetworkLoadBalancerIpAddressReservedIpArrayOutput

type GetNetworkLoadBalancerIpAddressReservedIpInput 

type GetNetworkLoadBalancerIpAddressReservedIpInput interface {
	pulumi.Input

	ToGetNetworkLoadBalancerIpAddressReservedIpOutput() GetNetworkLoadBalancerIpAddressReservedIpOutput
	ToGetNetworkLoadBalancerIpAddressReservedIpOutputWithContext(context.Context) GetNetworkLoadBalancerIpAddressReservedIpOutput
}

GetNetworkLoadBalancerIpAddressReservedIpInput is an input type that accepts GetNetworkLoadBalancerIpAddressReservedIpArgs and GetNetworkLoadBalancerIpAddressReservedIpOutput values. You can construct a concrete instance of `GetNetworkLoadBalancerIpAddressReservedIpInput` via: 

GetNetworkLoadBalancerIpAddressReservedIpArgs{...}

type GetNetworkLoadBalancerIpAddressReservedIpOutput 

type GetNetworkLoadBalancerIpAddressReservedIpOutput struct{ *pulumi.OutputState }

func (GetNetworkLoadBalancerIpAddressReservedIpOutput) ElementType 

func (GetNetworkLoadBalancerIpAddressReservedIpOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancerIpAddressReservedIpOutput) Id 

func (o GetNetworkLoadBalancerIpAddressReservedIpOutput) Id() pulumi.StringOutput

OCID of the reserved public IP address created with the virtual cloud network.

func (GetNetworkLoadBalancerIpAddressReservedIpOutput) ToGetNetworkLoadBalancerIpAddressReservedIpOutput 

func (o GetNetworkLoadBalancerIpAddressReservedIpOutput) ToGetNetworkLoadBalancerIpAddressReservedIpOutput() GetNetworkLoadBalancerIpAddressReservedIpOutput

func (GetNetworkLoadBalancerIpAddressReservedIpOutput) ToGetNetworkLoadBalancerIpAddressReservedIpOutputWithContext 

func (o GetNetworkLoadBalancerIpAddressReservedIpOutput) ToGetNetworkLoadBalancerIpAddressReservedIpOutputWithContext(ctx context.Context) GetNetworkLoadBalancerIpAddressReservedIpOutput

type GetNetworkLoadBalancerReservedIp 

type GetNetworkLoadBalancerReservedIp struct {
	// OCID of the reserved public IP address created with the virtual cloud network.
	Id string `pulumi:"id"`
}

type GetNetworkLoadBalancerReservedIpArgs 

type GetNetworkLoadBalancerReservedIpArgs struct {
	// OCID of the reserved public IP address created with the virtual cloud network.
	Id pulumi.StringInput `pulumi:"id"`
}

func (GetNetworkLoadBalancerReservedIpArgs) ElementType 

func (GetNetworkLoadBalancerReservedIpArgs) ElementType() reflect.Type

func (GetNetworkLoadBalancerReservedIpArgs) ToGetNetworkLoadBalancerReservedIpOutput 

func (i GetNetworkLoadBalancerReservedIpArgs) ToGetNetworkLoadBalancerReservedIpOutput() GetNetworkLoadBalancerReservedIpOutput

func (GetNetworkLoadBalancerReservedIpArgs) ToGetNetworkLoadBalancerReservedIpOutputWithContext 

func (i GetNetworkLoadBalancerReservedIpArgs) ToGetNetworkLoadBalancerReservedIpOutputWithContext(ctx context.Context) GetNetworkLoadBalancerReservedIpOutput

type GetNetworkLoadBalancerReservedIpArray 

type GetNetworkLoadBalancerReservedIpArray []GetNetworkLoadBalancerReservedIpInput

func (GetNetworkLoadBalancerReservedIpArray) ElementType 

func (GetNetworkLoadBalancerReservedIpArray) ElementType() reflect.Type

func (GetNetworkLoadBalancerReservedIpArray) ToGetNetworkLoadBalancerReservedIpArrayOutput 

func (i GetNetworkLoadBalancerReservedIpArray) ToGetNetworkLoadBalancerReservedIpArrayOutput() GetNetworkLoadBalancerReservedIpArrayOutput

func (GetNetworkLoadBalancerReservedIpArray) ToGetNetworkLoadBalancerReservedIpArrayOutputWithContext 

func (i GetNetworkLoadBalancerReservedIpArray) ToGetNetworkLoadBalancerReservedIpArrayOutputWithContext(ctx context.Context) GetNetworkLoadBalancerReservedIpArrayOutput

type GetNetworkLoadBalancerReservedIpArrayInput 

type GetNetworkLoadBalancerReservedIpArrayInput interface {
	pulumi.Input

	ToGetNetworkLoadBalancerReservedIpArrayOutput() GetNetworkLoadBalancerReservedIpArrayOutput
	ToGetNetworkLoadBalancerReservedIpArrayOutputWithContext(context.Context) GetNetworkLoadBalancerReservedIpArrayOutput
}

GetNetworkLoadBalancerReservedIpArrayInput is an input type that accepts GetNetworkLoadBalancerReservedIpArray and GetNetworkLoadBalancerReservedIpArrayOutput values. You can construct a concrete instance of `GetNetworkLoadBalancerReservedIpArrayInput` via: 

GetNetworkLoadBalancerReservedIpArray{ GetNetworkLoadBalancerReservedIpArgs{...} }

type GetNetworkLoadBalancerReservedIpArrayOutput 

type GetNetworkLoadBalancerReservedIpArrayOutput struct{ *pulumi.OutputState }

func (GetNetworkLoadBalancerReservedIpArrayOutput) ElementType 

func (GetNetworkLoadBalancerReservedIpArrayOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancerReservedIpArrayOutput) Index 

func (o GetNetworkLoadBalancerReservedIpArrayOutput) Index(i pulumi.IntInput) GetNetworkLoadBalancerReservedIpOutput

func (GetNetworkLoadBalancerReservedIpArrayOutput) ToGetNetworkLoadBalancerReservedIpArrayOutput 

func (o GetNetworkLoadBalancerReservedIpArrayOutput) ToGetNetworkLoadBalancerReservedIpArrayOutput() GetNetworkLoadBalancerReservedIpArrayOutput

func (GetNetworkLoadBalancerReservedIpArrayOutput) ToGetNetworkLoadBalancerReservedIpArrayOutputWithContext 

func (o GetNetworkLoadBalancerReservedIpArrayOutput) ToGetNetworkLoadBalancerReservedIpArrayOutputWithContext(ctx context.Context) GetNetworkLoadBalancerReservedIpArrayOutput

type GetNetworkLoadBalancerReservedIpInput 

type GetNetworkLoadBalancerReservedIpInput interface {
	pulumi.Input

	ToGetNetworkLoadBalancerReservedIpOutput() GetNetworkLoadBalancerReservedIpOutput
	ToGetNetworkLoadBalancerReservedIpOutputWithContext(context.Context) GetNetworkLoadBalancerReservedIpOutput
}

GetNetworkLoadBalancerReservedIpInput is an input type that accepts GetNetworkLoadBalancerReservedIpArgs and GetNetworkLoadBalancerReservedIpOutput values. You can construct a concrete instance of `GetNetworkLoadBalancerReservedIpInput` via: 

GetNetworkLoadBalancerReservedIpArgs{...}

type GetNetworkLoadBalancerReservedIpOutput 

type GetNetworkLoadBalancerReservedIpOutput struct{ *pulumi.OutputState }

func (GetNetworkLoadBalancerReservedIpOutput) ElementType 

func (GetNetworkLoadBalancerReservedIpOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancerReservedIpOutput) Id 

func (o GetNetworkLoadBalancerReservedIpOutput) Id() pulumi.StringOutput

OCID of the reserved public IP address created with the virtual cloud network.

func (GetNetworkLoadBalancerReservedIpOutput) ToGetNetworkLoadBalancerReservedIpOutput 

func (o GetNetworkLoadBalancerReservedIpOutput) ToGetNetworkLoadBalancerReservedIpOutput() GetNetworkLoadBalancerReservedIpOutput

func (GetNetworkLoadBalancerReservedIpOutput) ToGetNetworkLoadBalancerReservedIpOutputWithContext 

func (o GetNetworkLoadBalancerReservedIpOutput) ToGetNetworkLoadBalancerReservedIpOutputWithContext(ctx context.Context) GetNetworkLoadBalancerReservedIpOutput

type GetNetworkLoadBalancersArgs 

type GetNetworkLoadBalancersArgs struct {
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the compartment containing the network load balancers to list.
	CompartmentId string `pulumi:"compartmentId"`
	// A filter to return only resources that match the entire display name given.
	DisplayName *string                         `pulumi:"displayName"`
	Filters     []GetNetworkLoadBalancersFilter `pulumi:"filters"`
	// A filter to return only resources that match the given lifecycle state.
	State *string `pulumi:"state"`
}

A collection of arguments for invoking getNetworkLoadBalancers.

type GetNetworkLoadBalancersFilter 

type GetNetworkLoadBalancersFilter struct {
	// A friendly name for the listener. It must be unique and it cannot be changed.  Example: `exampleListener`
	Name   string   `pulumi:"name"`
	Regex  *bool    `pulumi:"regex"`
	Values []string `pulumi:"values"`
}

type GetNetworkLoadBalancersFilterArgs 

type GetNetworkLoadBalancersFilterArgs struct {
	// A friendly name for the listener. It must be unique and it cannot be changed.  Example: `exampleListener`
	Name   pulumi.StringInput      `pulumi:"name"`
	Regex  pulumi.BoolPtrInput     `pulumi:"regex"`
	Values pulumi.StringArrayInput `pulumi:"values"`
}

func (GetNetworkLoadBalancersFilterArgs) ElementType 

func (GetNetworkLoadBalancersFilterArgs) ElementType() reflect.Type

func (GetNetworkLoadBalancersFilterArgs) ToGetNetworkLoadBalancersFilterOutput 

func (i GetNetworkLoadBalancersFilterArgs) ToGetNetworkLoadBalancersFilterOutput() GetNetworkLoadBalancersFilterOutput

func (GetNetworkLoadBalancersFilterArgs) ToGetNetworkLoadBalancersFilterOutputWithContext 

func (i GetNetworkLoadBalancersFilterArgs) ToGetNetworkLoadBalancersFilterOutputWithContext(ctx context.Context) GetNetworkLoadBalancersFilterOutput

type GetNetworkLoadBalancersFilterArray 

type GetNetworkLoadBalancersFilterArray []GetNetworkLoadBalancersFilterInput

func (GetNetworkLoadBalancersFilterArray) ElementType 

func (GetNetworkLoadBalancersFilterArray) ElementType() reflect.Type

func (GetNetworkLoadBalancersFilterArray) ToGetNetworkLoadBalancersFilterArrayOutput 

func (i GetNetworkLoadBalancersFilterArray) ToGetNetworkLoadBalancersFilterArrayOutput() GetNetworkLoadBalancersFilterArrayOutput

func (GetNetworkLoadBalancersFilterArray) ToGetNetworkLoadBalancersFilterArrayOutputWithContext 

func (i GetNetworkLoadBalancersFilterArray) ToGetNetworkLoadBalancersFilterArrayOutputWithContext(ctx context.Context) GetNetworkLoadBalancersFilterArrayOutput

type GetNetworkLoadBalancersFilterArrayInput 

type GetNetworkLoadBalancersFilterArrayInput interface {
	pulumi.Input

	ToGetNetworkLoadBalancersFilterArrayOutput() GetNetworkLoadBalancersFilterArrayOutput
	ToGetNetworkLoadBalancersFilterArrayOutputWithContext(context.Context) GetNetworkLoadBalancersFilterArrayOutput
}

GetNetworkLoadBalancersFilterArrayInput is an input type that accepts GetNetworkLoadBalancersFilterArray and GetNetworkLoadBalancersFilterArrayOutput values. You can construct a concrete instance of `GetNetworkLoadBalancersFilterArrayInput` via: 

GetNetworkLoadBalancersFilterArray{ GetNetworkLoadBalancersFilterArgs{...} }

type GetNetworkLoadBalancersFilterArrayOutput 

type GetNetworkLoadBalancersFilterArrayOutput struct{ *pulumi.OutputState }

func (GetNetworkLoadBalancersFilterArrayOutput) ElementType 

func (GetNetworkLoadBalancersFilterArrayOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancersFilterArrayOutput) Index 

func (o GetNetworkLoadBalancersFilterArrayOutput) Index(i pulumi.IntInput) GetNetworkLoadBalancersFilterOutput

func (GetNetworkLoadBalancersFilterArrayOutput) ToGetNetworkLoadBalancersFilterArrayOutput 

func (o GetNetworkLoadBalancersFilterArrayOutput) ToGetNetworkLoadBalancersFilterArrayOutput() GetNetworkLoadBalancersFilterArrayOutput

func (GetNetworkLoadBalancersFilterArrayOutput) ToGetNetworkLoadBalancersFilterArrayOutputWithContext 

func (o GetNetworkLoadBalancersFilterArrayOutput) ToGetNetworkLoadBalancersFilterArrayOutputWithContext(ctx context.Context) GetNetworkLoadBalancersFilterArrayOutput

type GetNetworkLoadBalancersFilterInput 

type GetNetworkLoadBalancersFilterInput interface {
	pulumi.Input

	ToGetNetworkLoadBalancersFilterOutput() GetNetworkLoadBalancersFilterOutput
	ToGetNetworkLoadBalancersFilterOutputWithContext(context.Context) GetNetworkLoadBalancersFilterOutput
}

GetNetworkLoadBalancersFilterInput is an input type that accepts GetNetworkLoadBalancersFilterArgs and GetNetworkLoadBalancersFilterOutput values. You can construct a concrete instance of `GetNetworkLoadBalancersFilterInput` via: 

GetNetworkLoadBalancersFilterArgs{...}

type GetNetworkLoadBalancersFilterOutput 

type GetNetworkLoadBalancersFilterOutput struct{ *pulumi.OutputState }

func (GetNetworkLoadBalancersFilterOutput) ElementType 

func (GetNetworkLoadBalancersFilterOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancersFilterOutput) Name 

func (o GetNetworkLoadBalancersFilterOutput) Name() pulumi.StringOutput

A friendly name for the listener. It must be unique and it cannot be changed. Example: `exampleListener`

func (GetNetworkLoadBalancersFilterOutput) Regex 

func (o GetNetworkLoadBalancersFilterOutput) Regex() pulumi.BoolPtrOutput

func (GetNetworkLoadBalancersFilterOutput) ToGetNetworkLoadBalancersFilterOutput 

func (o GetNetworkLoadBalancersFilterOutput) ToGetNetworkLoadBalancersFilterOutput() GetNetworkLoadBalancersFilterOutput

func (GetNetworkLoadBalancersFilterOutput) ToGetNetworkLoadBalancersFilterOutputWithContext 

func (o GetNetworkLoadBalancersFilterOutput) ToGetNetworkLoadBalancersFilterOutputWithContext(ctx context.Context) GetNetworkLoadBalancersFilterOutput

func (GetNetworkLoadBalancersFilterOutput) Values 

func (o GetNetworkLoadBalancersFilterOutput) Values() pulumi.StringArrayOutput

type GetNetworkLoadBalancersNetworkLoadBalancerCollection 

type GetNetworkLoadBalancersNetworkLoadBalancerCollection struct {
	Items []GetNetworkLoadBalancersNetworkLoadBalancerCollectionItem `pulumi:"items"`
}

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionArgs 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionArgs struct {
	Items GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayInput `pulumi:"items"`
}

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionArgs) ElementType 

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionArgs) ElementType() reflect.Type

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionArgs) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionOutput 

func (i GetNetworkLoadBalancersNetworkLoadBalancerCollectionArgs) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionArgs) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionOutputWithContext 

func (i GetNetworkLoadBalancersNetworkLoadBalancerCollectionArgs) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionOutputWithContext(ctx context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionOutput

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionArray 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionArray []GetNetworkLoadBalancersNetworkLoadBalancerCollectionInput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionArray) ElementType 

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionArray) ElementType() reflect.Type

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionArray) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayOutput 

func (i GetNetworkLoadBalancersNetworkLoadBalancerCollectionArray) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionArray) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayOutputWithContext 

func (i GetNetworkLoadBalancersNetworkLoadBalancerCollectionArray) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayOutputWithContext(ctx context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayOutput

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayInput 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayInput interface {
	pulumi.Input

	ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayOutput
	ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayOutputWithContext(context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayOutput
}

GetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayInput is an input type that accepts GetNetworkLoadBalancersNetworkLoadBalancerCollectionArray and GetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayOutput values. You can construct a concrete instance of `GetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayInput` via: 

GetNetworkLoadBalancersNetworkLoadBalancerCollectionArray{ GetNetworkLoadBalancersNetworkLoadBalancerCollectionArgs{...} }

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayOutput 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayOutput struct{ *pulumi.OutputState }

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayOutput) ElementType 

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayOutput) Index 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayOutput) Index(i pulumi.IntInput) GetNetworkLoadBalancersNetworkLoadBalancerCollectionOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayOutput 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayOutputWithContext 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayOutputWithContext(ctx context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayOutput

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionInput 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionInput interface {
	pulumi.Input

	ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionOutput
	ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionOutputWithContext(context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionOutput
}

GetNetworkLoadBalancersNetworkLoadBalancerCollectionInput is an input type that accepts GetNetworkLoadBalancersNetworkLoadBalancerCollectionArgs and GetNetworkLoadBalancersNetworkLoadBalancerCollectionOutput values. You can construct a concrete instance of `GetNetworkLoadBalancersNetworkLoadBalancerCollectionInput` via: 

GetNetworkLoadBalancersNetworkLoadBalancerCollectionArgs{...}

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItem 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItem struct {
	AssignedIpv6        string `pulumi:"assignedIpv6"`
	AssignedPrivateIpv4 string `pulumi:"assignedPrivateIpv4"`
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the compartment containing the network load balancers to list.
	CompartmentId string `pulumi:"compartmentId"`
	// Defined tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm).  Example: `{"Operations.CostCenter": "42"}`
	DefinedTags map[string]string `pulumi:"definedTags"`
	// A filter to return only resources that match the entire display name given.
	DisplayName string `pulumi:"displayName"`
	// Free-form tags for this resource. Each tag is a simple key-value pair with no predefined name, type, or namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm).  Example: `{"Department": "Finance"}`
	FreeformTags map[string]string `pulumi:"freeformTags"`
	// OCID of the reserved public IP address created with the virtual cloud network.
	Id string `pulumi:"id"`
	// An array of IP addresses.
	IpAddresses []GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddress `pulumi:"ipAddresses"`
	// When enabled, the skipSourceDestinationCheck parameter is automatically enabled on the load balancer VNIC. Packets are sent to the backend set without any changes to the source and destination IP.
	IsPreserveSourceDestination bool `pulumi:"isPreserveSourceDestination"`
	// Whether the network load balancer has a virtual cloud network-local (private) IP address.
	IsPrivate              bool `pulumi:"isPrivate"`
	IsSymmetricHashEnabled bool `pulumi:"isSymmetricHashEnabled"`
	// A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
	LifecycleDetails string `pulumi:"lifecycleDetails"`
	// An array of network security groups [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) associated with the network load balancer.
	NetworkSecurityGroupIds []string `pulumi:"networkSecurityGroupIds"`
	// IP version associated with the NLB.
	NlbIpVersion string                                                               `pulumi:"nlbIpVersion"`
	ReservedIps  []GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIp `pulumi:"reservedIps"`
	// A filter to return only resources that match the given lifecycle state.
	State string `pulumi:"state"`
	// The subnet in which the network load balancer is spawned [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm)."
	SubnetId       string `pulumi:"subnetId"`
	SubnetIpv6cidr string `pulumi:"subnetIpv6cidr"`
	// Key-value pair representing system tags' keys and values scoped to a namespace. Example: `{"bar-key": "value"}`
	SystemTags map[string]string `pulumi:"systemTags"`
	// The date and time the network load balancer was created, in the format defined by RFC3339.  Example: `2020-05-01T21:10:29.600Z`
	TimeCreated string `pulumi:"timeCreated"`
	// The time the network load balancer was updated. An RFC3339 formatted date-time string.  Example: `2020-05-01T22:10:29.600Z`
	TimeUpdated string `pulumi:"timeUpdated"`
}

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArgs 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArgs struct {
	AssignedIpv6        pulumi.StringInput `pulumi:"assignedIpv6"`
	AssignedPrivateIpv4 pulumi.StringInput `pulumi:"assignedPrivateIpv4"`
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the compartment containing the network load balancers to list.
	CompartmentId pulumi.StringInput `pulumi:"compartmentId"`
	// Defined tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm).  Example: `{"Operations.CostCenter": "42"}`
	DefinedTags pulumi.StringMapInput `pulumi:"definedTags"`
	// A filter to return only resources that match the entire display name given.
	DisplayName pulumi.StringInput `pulumi:"displayName"`
	// Free-form tags for this resource. Each tag is a simple key-value pair with no predefined name, type, or namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm).  Example: `{"Department": "Finance"}`
	FreeformTags pulumi.StringMapInput `pulumi:"freeformTags"`
	// OCID of the reserved public IP address created with the virtual cloud network.
	Id pulumi.StringInput `pulumi:"id"`
	// An array of IP addresses.
	IpAddresses GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayInput `pulumi:"ipAddresses"`
	// When enabled, the skipSourceDestinationCheck parameter is automatically enabled on the load balancer VNIC. Packets are sent to the backend set without any changes to the source and destination IP.
	IsPreserveSourceDestination pulumi.BoolInput `pulumi:"isPreserveSourceDestination"`
	// Whether the network load balancer has a virtual cloud network-local (private) IP address.
	IsPrivate              pulumi.BoolInput `pulumi:"isPrivate"`
	IsSymmetricHashEnabled pulumi.BoolInput `pulumi:"isSymmetricHashEnabled"`
	// A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
	LifecycleDetails pulumi.StringInput `pulumi:"lifecycleDetails"`
	// An array of network security groups [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) associated with the network load balancer.
	NetworkSecurityGroupIds pulumi.StringArrayInput `pulumi:"networkSecurityGroupIds"`
	// IP version associated with the NLB.
	NlbIpVersion pulumi.StringInput                                                           `pulumi:"nlbIpVersion"`
	ReservedIps  GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayInput `pulumi:"reservedIps"`
	// A filter to return only resources that match the given lifecycle state.
	State pulumi.StringInput `pulumi:"state"`
	// The subnet in which the network load balancer is spawned [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm)."
	SubnetId       pulumi.StringInput `pulumi:"subnetId"`
	SubnetIpv6cidr pulumi.StringInput `pulumi:"subnetIpv6cidr"`
	// Key-value pair representing system tags' keys and values scoped to a namespace. Example: `{"bar-key": "value"}`
	SystemTags pulumi.StringMapInput `pulumi:"systemTags"`
	// The date and time the network load balancer was created, in the format defined by RFC3339.  Example: `2020-05-01T21:10:29.600Z`
	TimeCreated pulumi.StringInput `pulumi:"timeCreated"`
	// The time the network load balancer was updated. An RFC3339 formatted date-time string.  Example: `2020-05-01T22:10:29.600Z`
	TimeUpdated pulumi.StringInput `pulumi:"timeUpdated"`
}

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArgs) ElementType 

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArgs) ElementType() reflect.Type

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArgs) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput 

func (i GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArgs) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArgs) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutputWithContext 

func (i GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArgs) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutputWithContext(ctx context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArray 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArray []GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemInput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArray) ElementType 

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArray) ElementType() reflect.Type

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArray) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayOutput 

func (i GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArray) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArray) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayOutputWithContext 

func (i GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArray) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayOutputWithContext(ctx context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayOutput

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayInput 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayInput interface {
	pulumi.Input

	ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayOutput
	ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayOutputWithContext(context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayOutput
}

GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayInput is an input type that accepts GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArray and GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayOutput values. You can construct a concrete instance of `GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayInput` via: 

GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArray{ GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArgs{...} }

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayOutput 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayOutput struct{ *pulumi.OutputState }

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayOutput) ElementType 

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayOutput) Index 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayOutput) Index(i pulumi.IntInput) GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayOutput 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayOutputWithContext 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayOutputWithContext(ctx context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayOutput

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemInput 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemInput interface {
	pulumi.Input

	ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput
	ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutputWithContext(context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput
}

GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemInput is an input type that accepts GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArgs and GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput values. You can construct a concrete instance of `GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemInput` via: 

GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArgs{...}

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddress 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddress struct {
	// An IP address.  Example: `192.168.0.3`
	IpAddress string `pulumi:"ipAddress"`
	// IP version associated with the listener.
	IpVersion string `pulumi:"ipVersion"`
	// Whether the IP address is public or private.
	// If "true", then the IP address is public and accessible from the internet.
	IsPublic bool `pulumi:"isPublic"`
	// An object representing a reserved IP address to be attached or that is already attached to a network load balancer.
	ReservedIps []GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIp `pulumi:"reservedIps"`
}

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArgs 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArgs struct {
	// An IP address.  Example: `192.168.0.3`
	IpAddress pulumi.StringInput `pulumi:"ipAddress"`
	// IP version associated with the listener.
	IpVersion pulumi.StringInput `pulumi:"ipVersion"`
	// Whether the IP address is public or private.
	// If "true", then the IP address is public and accessible from the internet.
	IsPublic pulumi.BoolInput `pulumi:"isPublic"`
	// An object representing a reserved IP address to be attached or that is already attached to a network load balancer.
	ReservedIps GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayInput `pulumi:"reservedIps"`
}

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArgs) ElementType 

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArgs) ElementType() reflect.Type

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArgs) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutput 

func (i GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArgs) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArgs) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutputWithContext 

func (i GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArgs) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutputWithContext(ctx context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutput

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArray 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArray []GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressInput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArray) ElementType 

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArray) ElementType() reflect.Type

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArray) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayOutput 

func (i GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArray) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArray) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayOutputWithContext 

func (i GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArray) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayOutputWithContext(ctx context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayOutput

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayInput 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayInput interface {
	pulumi.Input

	ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayOutput
	ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayOutputWithContext(context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayOutput
}

GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayInput is an input type that accepts GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArray and GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayOutput values. You can construct a concrete instance of `GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayInput` via: 

GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArray{ GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArgs{...} }

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayOutput 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayOutput struct{ *pulumi.OutputState }

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayOutput) ElementType 

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayOutput) Index 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayOutput) Index(i pulumi.IntInput) GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayOutput 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayOutputWithContext 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayOutputWithContext(ctx context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayOutput

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressInput 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressInput interface {
	pulumi.Input

	ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutput
	ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutputWithContext(context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutput
}

GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressInput is an input type that accepts GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArgs and GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutput values. You can construct a concrete instance of `GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressInput` via: 

GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArgs{...}

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutput 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutput struct{ *pulumi.OutputState }

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutput) ElementType 

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutput) IpAddress 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutput) IpAddress() pulumi.StringOutput

An IP address. Example: `192.168.0.3`

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutput) IpVersion 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutput) IpVersion() pulumi.StringOutput

IP version associated with the listener.

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutput) IsPublic 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutput) IsPublic() pulumi.BoolOutput

Whether the IP address is public or private. If "true", then the IP address is public and accessible from the internet.

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutput) ReservedIps 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutput) ReservedIps() GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayOutput

An object representing a reserved IP address to be attached or that is already attached to a network load balancer.

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutput 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutputWithContext 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutputWithContext(ctx context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressOutput

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIp 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIp struct {
	// OCID of the reserved public IP address created with the virtual cloud network.
	Id string `pulumi:"id"`
}

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArgs 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArgs struct {
	// OCID of the reserved public IP address created with the virtual cloud network.
	Id pulumi.StringInput `pulumi:"id"`
}

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArgs) ElementType 

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArgs) ElementType() reflect.Type

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArgs) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpOutput 

func (i GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArgs) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArgs) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpOutputWithContext 

func (i GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArgs) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpOutputWithContext(ctx context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpOutput

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArray 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArray []GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpInput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArray) ElementType 

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArray) ElementType() reflect.Type

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArray) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayOutput 

func (i GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArray) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArray) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayOutputWithContext 

func (i GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArray) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayOutputWithContext(ctx context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayOutput

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayInput 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayInput interface {
	pulumi.Input

	ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayOutput
	ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayOutputWithContext(context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayOutput
}

GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayInput is an input type that accepts GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArray and GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayOutput values. You can construct a concrete instance of `GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayInput` via: 

GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArray{ GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArgs{...} }

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayOutput 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayOutput struct{ *pulumi.OutputState }

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayOutput) ElementType 

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayOutput) Index 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayOutput) Index(i pulumi.IntInput) GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayOutput 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayOutputWithContext 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayOutputWithContext(ctx context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArrayOutput

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpInput 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpInput interface {
	pulumi.Input

	ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpOutput
	ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpOutputWithContext(context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpOutput
}

GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpInput is an input type that accepts GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArgs and GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpOutput values. You can construct a concrete instance of `GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpInput` via: 

GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpArgs{...}

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpOutput 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpOutput struct{ *pulumi.OutputState }

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpOutput) ElementType 

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpOutput) Id 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpOutput) Id() pulumi.StringOutput

OCID of the reserved public IP address created with the virtual cloud network.

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpOutput 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpOutputWithContext 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpOutputWithContext(ctx context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressReservedIpOutput

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput struct{ *pulumi.OutputState }

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) AssignedIpv6 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) AssignedIpv6() pulumi.StringOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) AssignedPrivateIpv4 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) AssignedPrivateIpv4() pulumi.StringOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) CompartmentId 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) CompartmentId() pulumi.StringOutput

The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the compartment containing the network load balancers to list.

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) DefinedTags 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) DefinedTags() pulumi.StringMapOutput

Defined tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm). Example: `{"Operations.CostCenter": "42"}`

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) DisplayName 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) DisplayName() pulumi.StringOutput

A filter to return only resources that match the entire display name given.

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) ElementType 

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) FreeformTags 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) FreeformTags() pulumi.StringMapOutput

Free-form tags for this resource. Each tag is a simple key-value pair with no predefined name, type, or namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm). Example: `{"Department": "Finance"}`

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) Id 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) Id() pulumi.StringOutput

OCID of the reserved public IP address created with the virtual cloud network.

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) IpAddresses 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) IpAddresses() GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemIpAddressArrayOutput

An array of IP addresses.

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) IsPreserveSourceDestination 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) IsPreserveSourceDestination() pulumi.BoolOutput

When enabled, the skipSourceDestinationCheck parameter is automatically enabled on the load balancer VNIC. Packets are sent to the backend set without any changes to the source and destination IP.

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) IsPrivate 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) IsPrivate() pulumi.BoolOutput

Whether the network load balancer has a virtual cloud network-local (private) IP address.

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) IsSymmetricHashEnabled 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) IsSymmetricHashEnabled() pulumi.BoolOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) LifecycleDetails 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) LifecycleDetails() pulumi.StringOutput

A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) NetworkSecurityGroupIds 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) NetworkSecurityGroupIds() pulumi.StringArrayOutput

An array of network security groups [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) associated with the network load balancer.

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) NlbIpVersion 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) NlbIpVersion() pulumi.StringOutput

IP version associated with the NLB.

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) ReservedIps 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) ReservedIps() GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) State 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) State() pulumi.StringOutput

A filter to return only resources that match the given lifecycle state.

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) SubnetId 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) SubnetId() pulumi.StringOutput

The subnet in which the network load balancer is spawned [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm)."

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) SubnetIpv6cidr 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) SubnetIpv6cidr() pulumi.StringOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) SystemTags 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) SystemTags() pulumi.StringMapOutput

Key-value pair representing system tags' keys and values scoped to a namespace. Example: `{"bar-key": "value"}`

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) TimeCreated 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) TimeCreated() pulumi.StringOutput

The date and time the network load balancer was created, in the format defined by RFC3339. Example: `2020-05-01T21:10:29.600Z`

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) TimeUpdated 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) TimeUpdated() pulumi.StringOutput

The time the network load balancer was updated. An RFC3339 formatted date-time string. Example: `2020-05-01T22:10:29.600Z`

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutputWithContext 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutputWithContext(ctx context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemOutput

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIp 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIp struct {
	// OCID of the reserved public IP address created with the virtual cloud network.
	Id string `pulumi:"id"`
}

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArgs 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArgs struct {
	// OCID of the reserved public IP address created with the virtual cloud network.
	Id pulumi.StringInput `pulumi:"id"`
}

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArgs) ElementType 

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArgs) ElementType() reflect.Type

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArgs) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpOutput 

func (i GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArgs) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArgs) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpOutputWithContext 

func (i GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArgs) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpOutputWithContext(ctx context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpOutput

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArray 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArray []GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpInput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArray) ElementType 

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArray) ElementType() reflect.Type

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArray) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayOutput 

func (i GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArray) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArray) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayOutputWithContext 

func (i GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArray) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayOutputWithContext(ctx context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayOutput

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayInput 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayInput interface {
	pulumi.Input

	ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayOutput
	ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayOutputWithContext(context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayOutput
}

GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayInput is an input type that accepts GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArray and GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayOutput values. You can construct a concrete instance of `GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayInput` via: 

GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArray{ GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArgs{...} }

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayOutput 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayOutput struct{ *pulumi.OutputState }

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayOutput) ElementType 

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayOutput) Index 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayOutput) Index(i pulumi.IntInput) GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayOutput 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayOutputWithContext 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayOutputWithContext(ctx context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArrayOutput

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpInput 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpInput interface {
	pulumi.Input

	ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpOutput
	ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpOutputWithContext(context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpOutput
}

GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpInput is an input type that accepts GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArgs and GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpOutput values. You can construct a concrete instance of `GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpInput` via: 

GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpArgs{...}

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpOutput 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpOutput struct{ *pulumi.OutputState }

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpOutput) ElementType 

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpOutput) Id 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpOutput) Id() pulumi.StringOutput

OCID of the reserved public IP address created with the virtual cloud network.

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpOutput 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpOutputWithContext 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpOutputWithContext(ctx context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemReservedIpOutput

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionOutput 

type GetNetworkLoadBalancersNetworkLoadBalancerCollectionOutput struct{ *pulumi.OutputState }

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionOutput) ElementType 

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionOutput) Items 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionOutput) Items() GetNetworkLoadBalancersNetworkLoadBalancerCollectionItemArrayOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionOutput 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionOutput() GetNetworkLoadBalancersNetworkLoadBalancerCollectionOutput

func (GetNetworkLoadBalancersNetworkLoadBalancerCollectionOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionOutputWithContext 

func (o GetNetworkLoadBalancersNetworkLoadBalancerCollectionOutput) ToGetNetworkLoadBalancersNetworkLoadBalancerCollectionOutputWithContext(ctx context.Context) GetNetworkLoadBalancersNetworkLoadBalancerCollectionOutput

type GetNetworkLoadBalancersOutputArgs 

type GetNetworkLoadBalancersOutputArgs struct {
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the compartment containing the network load balancers to list.
	CompartmentId pulumi.StringInput `pulumi:"compartmentId"`
	// A filter to return only resources that match the entire display name given.
	DisplayName pulumi.StringPtrInput                   `pulumi:"displayName"`
	Filters     GetNetworkLoadBalancersFilterArrayInput `pulumi:"filters"`
	// A filter to return only resources that match the given lifecycle state.
	State pulumi.StringPtrInput `pulumi:"state"`
}

A collection of arguments for invoking getNetworkLoadBalancers.

func (GetNetworkLoadBalancersOutputArgs) ElementType 

func (GetNetworkLoadBalancersOutputArgs) ElementType() reflect.Type

type GetNetworkLoadBalancersPoliciesArgs 

type GetNetworkLoadBalancersPoliciesArgs struct {
	Filters []GetNetworkLoadBalancersPoliciesFilter `pulumi:"filters"`
}

A collection of arguments for invoking getNetworkLoadBalancersPolicies.

type GetNetworkLoadBalancersPoliciesFilter 

type GetNetworkLoadBalancersPoliciesFilter struct {
	Name   string   `pulumi:"name"`
	Regex  *bool    `pulumi:"regex"`
	Values []string `pulumi:"values"`
}

type GetNetworkLoadBalancersPoliciesFilterArgs 

type GetNetworkLoadBalancersPoliciesFilterArgs struct {
	Name   pulumi.StringInput      `pulumi:"name"`
	Regex  pulumi.BoolPtrInput     `pulumi:"regex"`
	Values pulumi.StringArrayInput `pulumi:"values"`
}

func (GetNetworkLoadBalancersPoliciesFilterArgs) ElementType 

func (GetNetworkLoadBalancersPoliciesFilterArgs) ElementType() reflect.Type

func (GetNetworkLoadBalancersPoliciesFilterArgs) ToGetNetworkLoadBalancersPoliciesFilterOutput 

func (i GetNetworkLoadBalancersPoliciesFilterArgs) ToGetNetworkLoadBalancersPoliciesFilterOutput() GetNetworkLoadBalancersPoliciesFilterOutput

func (GetNetworkLoadBalancersPoliciesFilterArgs) ToGetNetworkLoadBalancersPoliciesFilterOutputWithContext 

func (i GetNetworkLoadBalancersPoliciesFilterArgs) ToGetNetworkLoadBalancersPoliciesFilterOutputWithContext(ctx context.Context) GetNetworkLoadBalancersPoliciesFilterOutput

type GetNetworkLoadBalancersPoliciesFilterArray 

type GetNetworkLoadBalancersPoliciesFilterArray []GetNetworkLoadBalancersPoliciesFilterInput

func (GetNetworkLoadBalancersPoliciesFilterArray) ElementType 

func (GetNetworkLoadBalancersPoliciesFilterArray) ElementType() reflect.Type

func (GetNetworkLoadBalancersPoliciesFilterArray) ToGetNetworkLoadBalancersPoliciesFilterArrayOutput 

func (i GetNetworkLoadBalancersPoliciesFilterArray) ToGetNetworkLoadBalancersPoliciesFilterArrayOutput() GetNetworkLoadBalancersPoliciesFilterArrayOutput

func (GetNetworkLoadBalancersPoliciesFilterArray) ToGetNetworkLoadBalancersPoliciesFilterArrayOutputWithContext 

func (i GetNetworkLoadBalancersPoliciesFilterArray) ToGetNetworkLoadBalancersPoliciesFilterArrayOutputWithContext(ctx context.Context) GetNetworkLoadBalancersPoliciesFilterArrayOutput

type GetNetworkLoadBalancersPoliciesFilterArrayInput 

type GetNetworkLoadBalancersPoliciesFilterArrayInput interface {
	pulumi.Input

	ToGetNetworkLoadBalancersPoliciesFilterArrayOutput() GetNetworkLoadBalancersPoliciesFilterArrayOutput
	ToGetNetworkLoadBalancersPoliciesFilterArrayOutputWithContext(context.Context) GetNetworkLoadBalancersPoliciesFilterArrayOutput
}

GetNetworkLoadBalancersPoliciesFilterArrayInput is an input type that accepts GetNetworkLoadBalancersPoliciesFilterArray and GetNetworkLoadBalancersPoliciesFilterArrayOutput values. You can construct a concrete instance of `GetNetworkLoadBalancersPoliciesFilterArrayInput` via: 

GetNetworkLoadBalancersPoliciesFilterArray{ GetNetworkLoadBalancersPoliciesFilterArgs{...} }

type GetNetworkLoadBalancersPoliciesFilterArrayOutput 

type GetNetworkLoadBalancersPoliciesFilterArrayOutput struct{ *pulumi.OutputState }

func (GetNetworkLoadBalancersPoliciesFilterArrayOutput) ElementType 

func (GetNetworkLoadBalancersPoliciesFilterArrayOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancersPoliciesFilterArrayOutput) Index 

func (o GetNetworkLoadBalancersPoliciesFilterArrayOutput) Index(i pulumi.IntInput) GetNetworkLoadBalancersPoliciesFilterOutput

func (GetNetworkLoadBalancersPoliciesFilterArrayOutput) ToGetNetworkLoadBalancersPoliciesFilterArrayOutput 

func (o GetNetworkLoadBalancersPoliciesFilterArrayOutput) ToGetNetworkLoadBalancersPoliciesFilterArrayOutput() GetNetworkLoadBalancersPoliciesFilterArrayOutput

func (GetNetworkLoadBalancersPoliciesFilterArrayOutput) ToGetNetworkLoadBalancersPoliciesFilterArrayOutputWithContext 

func (o GetNetworkLoadBalancersPoliciesFilterArrayOutput) ToGetNetworkLoadBalancersPoliciesFilterArrayOutputWithContext(ctx context.Context) GetNetworkLoadBalancersPoliciesFilterArrayOutput

type GetNetworkLoadBalancersPoliciesFilterInput 

type GetNetworkLoadBalancersPoliciesFilterInput interface {
	pulumi.Input

	ToGetNetworkLoadBalancersPoliciesFilterOutput() GetNetworkLoadBalancersPoliciesFilterOutput
	ToGetNetworkLoadBalancersPoliciesFilterOutputWithContext(context.Context) GetNetworkLoadBalancersPoliciesFilterOutput
}

GetNetworkLoadBalancersPoliciesFilterInput is an input type that accepts GetNetworkLoadBalancersPoliciesFilterArgs and GetNetworkLoadBalancersPoliciesFilterOutput values. You can construct a concrete instance of `GetNetworkLoadBalancersPoliciesFilterInput` via: 

GetNetworkLoadBalancersPoliciesFilterArgs{...}

type GetNetworkLoadBalancersPoliciesFilterOutput 

type GetNetworkLoadBalancersPoliciesFilterOutput struct{ *pulumi.OutputState }

func (GetNetworkLoadBalancersPoliciesFilterOutput) ElementType 

func (GetNetworkLoadBalancersPoliciesFilterOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancersPoliciesFilterOutput) Name 

func (o GetNetworkLoadBalancersPoliciesFilterOutput) Name() pulumi.StringOutput

func (GetNetworkLoadBalancersPoliciesFilterOutput) Regex 

func (o GetNetworkLoadBalancersPoliciesFilterOutput) Regex() pulumi.BoolPtrOutput

func (GetNetworkLoadBalancersPoliciesFilterOutput) ToGetNetworkLoadBalancersPoliciesFilterOutput 

func (o GetNetworkLoadBalancersPoliciesFilterOutput) ToGetNetworkLoadBalancersPoliciesFilterOutput() GetNetworkLoadBalancersPoliciesFilterOutput

func (GetNetworkLoadBalancersPoliciesFilterOutput) ToGetNetworkLoadBalancersPoliciesFilterOutputWithContext 

func (o GetNetworkLoadBalancersPoliciesFilterOutput) ToGetNetworkLoadBalancersPoliciesFilterOutputWithContext(ctx context.Context) GetNetworkLoadBalancersPoliciesFilterOutput

func (GetNetworkLoadBalancersPoliciesFilterOutput) Values 

func (o GetNetworkLoadBalancersPoliciesFilterOutput) Values() pulumi.StringArrayOutput

type GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollection 

type GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollection struct {
	// Array of NetworkLoadBalancersPolicySummary objects.
	Items []string `pulumi:"items"`
}

type GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArgs 

type GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArgs struct {
	// Array of NetworkLoadBalancersPolicySummary objects.
	Items pulumi.StringArrayInput `pulumi:"items"`
}

func (GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArgs) ElementType 

func (GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArgs) ElementType() reflect.Type

func (GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArgs) ToGetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionOutput 

func (i GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArgs) ToGetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionOutput() GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionOutput

func (GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArgs) ToGetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionOutputWithContext 

func (i GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArgs) ToGetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionOutputWithContext(ctx context.Context) GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionOutput

type GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArray 

type GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArray []GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionInput

func (GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArray) ElementType 

func (GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArray) ElementType() reflect.Type

func (GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArray) ToGetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayOutput 

func (i GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArray) ToGetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayOutput() GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayOutput

func (GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArray) ToGetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayOutputWithContext 

func (i GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArray) ToGetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayOutputWithContext(ctx context.Context) GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayOutput

type GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayInput 

type GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayInput interface {
	pulumi.Input

	ToGetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayOutput() GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayOutput
	ToGetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayOutputWithContext(context.Context) GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayOutput
}

GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayInput is an input type that accepts GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArray and GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayOutput values. You can construct a concrete instance of `GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayInput` via: 

GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArray{ GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArgs{...} }

type GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayOutput 

type GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayOutput struct{ *pulumi.OutputState }

func (GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayOutput) ElementType 

func (GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayOutput) Index 

func (o GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayOutput) Index(i pulumi.IntInput) GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionOutput

func (GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayOutput) ToGetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayOutput 

func (o GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayOutput) ToGetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayOutput() GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayOutput

func (GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayOutput) ToGetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayOutputWithContext 

func (o GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayOutput) ToGetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayOutputWithContext(ctx context.Context) GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayOutput

type GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionInput 

type GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionInput interface {
	pulumi.Input

	ToGetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionOutput() GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionOutput
	ToGetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionOutputWithContext(context.Context) GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionOutput
}

GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionInput is an input type that accepts GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArgs and GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionOutput values. You can construct a concrete instance of `GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionInput` via: 

GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArgs{...}

type GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionOutput 

type GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionOutput struct{ *pulumi.OutputState }

func (GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionOutput) ElementType 

func (GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionOutput) Items 

func (o GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionOutput) Items() pulumi.StringArrayOutput

Array of NetworkLoadBalancersPolicySummary objects.

func (GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionOutput) ToGetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionOutput 

func (o GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionOutput) ToGetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionOutput() GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionOutput

func (GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionOutput) ToGetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionOutputWithContext 

func (o GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionOutput) ToGetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionOutputWithContext(ctx context.Context) GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionOutput

type GetNetworkLoadBalancersPoliciesOutputArgs 

type GetNetworkLoadBalancersPoliciesOutputArgs struct {
	Filters GetNetworkLoadBalancersPoliciesFilterArrayInput `pulumi:"filters"`
}

A collection of arguments for invoking getNetworkLoadBalancersPolicies.

func (GetNetworkLoadBalancersPoliciesOutputArgs) ElementType 

func (GetNetworkLoadBalancersPoliciesOutputArgs) ElementType() reflect.Type

type GetNetworkLoadBalancersPoliciesResult 

type GetNetworkLoadBalancersPoliciesResult struct {
	Filters []GetNetworkLoadBalancersPoliciesFilter `pulumi:"filters"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// The list of network_load_balancers_policy_collection.
	NetworkLoadBalancersPolicyCollections []GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollection `pulumi:"networkLoadBalancersPolicyCollections"`
}

A collection of values returned by getNetworkLoadBalancersPolicies.

func GetNetworkLoadBalancersPolicies 

func GetNetworkLoadBalancersPolicies(ctx *pulumi.Context, args *GetNetworkLoadBalancersPoliciesArgs, opts ...pulumi.InvokeOption) (*GetNetworkLoadBalancersPoliciesResult, error)

This data source provides the list of Network Load Balancers Policies in Oracle Cloud Infrastructure Network Load Balancer service.

Lists the available network load balancer policies.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-oci/sdk/v2/go/oci/NetworkLoadBalancer"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := NetworkLoadBalancer.GetNetworkLoadBalancersPolicies(ctx, nil, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type GetNetworkLoadBalancersPoliciesResultOutput 

type GetNetworkLoadBalancersPoliciesResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getNetworkLoadBalancersPolicies.

func GetNetworkLoadBalancersPoliciesOutput 

func GetNetworkLoadBalancersPoliciesOutput(ctx *pulumi.Context, args GetNetworkLoadBalancersPoliciesOutputArgs, opts ...pulumi.InvokeOption) GetNetworkLoadBalancersPoliciesResultOutput

func (GetNetworkLoadBalancersPoliciesResultOutput) ElementType 

func (GetNetworkLoadBalancersPoliciesResultOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancersPoliciesResultOutput) Filters 

func (o GetNetworkLoadBalancersPoliciesResultOutput) Filters() GetNetworkLoadBalancersPoliciesFilterArrayOutput

func (GetNetworkLoadBalancersPoliciesResultOutput) Id 

func (o GetNetworkLoadBalancersPoliciesResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (GetNetworkLoadBalancersPoliciesResultOutput) NetworkLoadBalancersPolicyCollections 

func (o GetNetworkLoadBalancersPoliciesResultOutput) NetworkLoadBalancersPolicyCollections() GetNetworkLoadBalancersPoliciesNetworkLoadBalancersPolicyCollectionArrayOutput

The list of network_load_balancers_policy_collection.

func (GetNetworkLoadBalancersPoliciesResultOutput) ToGetNetworkLoadBalancersPoliciesResultOutput 

func (o GetNetworkLoadBalancersPoliciesResultOutput) ToGetNetworkLoadBalancersPoliciesResultOutput() GetNetworkLoadBalancersPoliciesResultOutput

func (GetNetworkLoadBalancersPoliciesResultOutput) ToGetNetworkLoadBalancersPoliciesResultOutputWithContext 

func (o GetNetworkLoadBalancersPoliciesResultOutput) ToGetNetworkLoadBalancersPoliciesResultOutputWithContext(ctx context.Context) GetNetworkLoadBalancersPoliciesResultOutput

type GetNetworkLoadBalancersProtocolsArgs 

type GetNetworkLoadBalancersProtocolsArgs struct {
	Filters []GetNetworkLoadBalancersProtocolsFilter `pulumi:"filters"`
}

A collection of arguments for invoking getNetworkLoadBalancersProtocols.

type GetNetworkLoadBalancersProtocolsFilter 

type GetNetworkLoadBalancersProtocolsFilter struct {
	Name   string   `pulumi:"name"`
	Regex  *bool    `pulumi:"regex"`
	Values []string `pulumi:"values"`
}

type GetNetworkLoadBalancersProtocolsFilterArgs 

type GetNetworkLoadBalancersProtocolsFilterArgs struct {
	Name   pulumi.StringInput      `pulumi:"name"`
	Regex  pulumi.BoolPtrInput     `pulumi:"regex"`
	Values pulumi.StringArrayInput `pulumi:"values"`
}

func (GetNetworkLoadBalancersProtocolsFilterArgs) ElementType 

func (GetNetworkLoadBalancersProtocolsFilterArgs) ElementType() reflect.Type

func (GetNetworkLoadBalancersProtocolsFilterArgs) ToGetNetworkLoadBalancersProtocolsFilterOutput 

func (i GetNetworkLoadBalancersProtocolsFilterArgs) ToGetNetworkLoadBalancersProtocolsFilterOutput() GetNetworkLoadBalancersProtocolsFilterOutput

func (GetNetworkLoadBalancersProtocolsFilterArgs) ToGetNetworkLoadBalancersProtocolsFilterOutputWithContext 

func (i GetNetworkLoadBalancersProtocolsFilterArgs) ToGetNetworkLoadBalancersProtocolsFilterOutputWithContext(ctx context.Context) GetNetworkLoadBalancersProtocolsFilterOutput

type GetNetworkLoadBalancersProtocolsFilterArray 

type GetNetworkLoadBalancersProtocolsFilterArray []GetNetworkLoadBalancersProtocolsFilterInput

func (GetNetworkLoadBalancersProtocolsFilterArray) ElementType 

func (GetNetworkLoadBalancersProtocolsFilterArray) ElementType() reflect.Type

func (GetNetworkLoadBalancersProtocolsFilterArray) ToGetNetworkLoadBalancersProtocolsFilterArrayOutput 

func (i GetNetworkLoadBalancersProtocolsFilterArray) ToGetNetworkLoadBalancersProtocolsFilterArrayOutput() GetNetworkLoadBalancersProtocolsFilterArrayOutput

func (GetNetworkLoadBalancersProtocolsFilterArray) ToGetNetworkLoadBalancersProtocolsFilterArrayOutputWithContext 

func (i GetNetworkLoadBalancersProtocolsFilterArray) ToGetNetworkLoadBalancersProtocolsFilterArrayOutputWithContext(ctx context.Context) GetNetworkLoadBalancersProtocolsFilterArrayOutput

type GetNetworkLoadBalancersProtocolsFilterArrayInput 

type GetNetworkLoadBalancersProtocolsFilterArrayInput interface {
	pulumi.Input

	ToGetNetworkLoadBalancersProtocolsFilterArrayOutput() GetNetworkLoadBalancersProtocolsFilterArrayOutput
	ToGetNetworkLoadBalancersProtocolsFilterArrayOutputWithContext(context.Context) GetNetworkLoadBalancersProtocolsFilterArrayOutput
}

GetNetworkLoadBalancersProtocolsFilterArrayInput is an input type that accepts GetNetworkLoadBalancersProtocolsFilterArray and GetNetworkLoadBalancersProtocolsFilterArrayOutput values. You can construct a concrete instance of `GetNetworkLoadBalancersProtocolsFilterArrayInput` via: 

GetNetworkLoadBalancersProtocolsFilterArray{ GetNetworkLoadBalancersProtocolsFilterArgs{...} }

type GetNetworkLoadBalancersProtocolsFilterArrayOutput 

type GetNetworkLoadBalancersProtocolsFilterArrayOutput struct{ *pulumi.OutputState }

func (GetNetworkLoadBalancersProtocolsFilterArrayOutput) ElementType 

func (GetNetworkLoadBalancersProtocolsFilterArrayOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancersProtocolsFilterArrayOutput) Index 

func (o GetNetworkLoadBalancersProtocolsFilterArrayOutput) Index(i pulumi.IntInput) GetNetworkLoadBalancersProtocolsFilterOutput

func (GetNetworkLoadBalancersProtocolsFilterArrayOutput) ToGetNetworkLoadBalancersProtocolsFilterArrayOutput 

func (o GetNetworkLoadBalancersProtocolsFilterArrayOutput) ToGetNetworkLoadBalancersProtocolsFilterArrayOutput() GetNetworkLoadBalancersProtocolsFilterArrayOutput

func (GetNetworkLoadBalancersProtocolsFilterArrayOutput) ToGetNetworkLoadBalancersProtocolsFilterArrayOutputWithContext 

func (o GetNetworkLoadBalancersProtocolsFilterArrayOutput) ToGetNetworkLoadBalancersProtocolsFilterArrayOutputWithContext(ctx context.Context) GetNetworkLoadBalancersProtocolsFilterArrayOutput

type GetNetworkLoadBalancersProtocolsFilterInput 

type GetNetworkLoadBalancersProtocolsFilterInput interface {
	pulumi.Input

	ToGetNetworkLoadBalancersProtocolsFilterOutput() GetNetworkLoadBalancersProtocolsFilterOutput
	ToGetNetworkLoadBalancersProtocolsFilterOutputWithContext(context.Context) GetNetworkLoadBalancersProtocolsFilterOutput
}

GetNetworkLoadBalancersProtocolsFilterInput is an input type that accepts GetNetworkLoadBalancersProtocolsFilterArgs and GetNetworkLoadBalancersProtocolsFilterOutput values. You can construct a concrete instance of `GetNetworkLoadBalancersProtocolsFilterInput` via: 

GetNetworkLoadBalancersProtocolsFilterArgs{...}

type GetNetworkLoadBalancersProtocolsFilterOutput 

type GetNetworkLoadBalancersProtocolsFilterOutput struct{ *pulumi.OutputState }

func (GetNetworkLoadBalancersProtocolsFilterOutput) ElementType 

func (GetNetworkLoadBalancersProtocolsFilterOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancersProtocolsFilterOutput) Name 

func (o GetNetworkLoadBalancersProtocolsFilterOutput) Name() pulumi.StringOutput

func (GetNetworkLoadBalancersProtocolsFilterOutput) Regex 

func (o GetNetworkLoadBalancersProtocolsFilterOutput) Regex() pulumi.BoolPtrOutput

func (GetNetworkLoadBalancersProtocolsFilterOutput) ToGetNetworkLoadBalancersProtocolsFilterOutput 

func (o GetNetworkLoadBalancersProtocolsFilterOutput) ToGetNetworkLoadBalancersProtocolsFilterOutput() GetNetworkLoadBalancersProtocolsFilterOutput

func (GetNetworkLoadBalancersProtocolsFilterOutput) ToGetNetworkLoadBalancersProtocolsFilterOutputWithContext 

func (o GetNetworkLoadBalancersProtocolsFilterOutput) ToGetNetworkLoadBalancersProtocolsFilterOutputWithContext(ctx context.Context) GetNetworkLoadBalancersProtocolsFilterOutput

func (GetNetworkLoadBalancersProtocolsFilterOutput) Values 

func (o GetNetworkLoadBalancersProtocolsFilterOutput) Values() pulumi.StringArrayOutput

type GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollection 

type GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollection struct {
	// Array of NetworkLoadBalancersProtocolSummary objects.
	Items []string `pulumi:"items"`
}

type GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArgs 

type GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArgs struct {
	// Array of NetworkLoadBalancersProtocolSummary objects.
	Items pulumi.StringArrayInput `pulumi:"items"`
}

func (GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArgs) ElementType 

func (GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArgs) ElementType() reflect.Type

func (GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArgs) ToGetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionOutput 

func (i GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArgs) ToGetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionOutput() GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionOutput

func (GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArgs) ToGetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionOutputWithContext 

func (i GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArgs) ToGetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionOutputWithContext(ctx context.Context) GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionOutput

type GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArray 

type GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArray []GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionInput

func (GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArray) ElementType 

func (GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArray) ElementType() reflect.Type

func (GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArray) ToGetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayOutput 

func (i GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArray) ToGetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayOutput() GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayOutput

func (GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArray) ToGetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayOutputWithContext 

func (i GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArray) ToGetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayOutputWithContext(ctx context.Context) GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayOutput

type GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayInput 

type GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayInput interface {
	pulumi.Input

	ToGetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayOutput() GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayOutput
	ToGetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayOutputWithContext(context.Context) GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayOutput
}

GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayInput is an input type that accepts GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArray and GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayOutput values. You can construct a concrete instance of `GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayInput` via: 

GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArray{ GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArgs{...} }

type GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayOutput 

type GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayOutput struct{ *pulumi.OutputState }

func (GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayOutput) ElementType 

func (GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayOutput) Index 

func (o GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayOutput) Index(i pulumi.IntInput) GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionOutput

func (GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayOutput) ToGetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayOutput 

func (o GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayOutput) ToGetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayOutput() GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayOutput

func (GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayOutput) ToGetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayOutputWithContext 

func (o GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayOutput) ToGetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayOutputWithContext(ctx context.Context) GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayOutput

type GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionInput 

type GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionInput interface {
	pulumi.Input

	ToGetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionOutput() GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionOutput
	ToGetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionOutputWithContext(context.Context) GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionOutput
}

GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionInput is an input type that accepts GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArgs and GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionOutput values. You can construct a concrete instance of `GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionInput` via: 

GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArgs{...}

type GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionOutput 

type GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionOutput struct{ *pulumi.OutputState }

func (GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionOutput) ElementType 

func (GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionOutput) Items 

func (o GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionOutput) Items() pulumi.StringArrayOutput

Array of NetworkLoadBalancersProtocolSummary objects.

func (GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionOutput) ToGetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionOutput 

func (o GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionOutput) ToGetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionOutput() GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionOutput

func (GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionOutput) ToGetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionOutputWithContext 

func (o GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionOutput) ToGetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionOutputWithContext(ctx context.Context) GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionOutput

type GetNetworkLoadBalancersProtocolsOutputArgs 

type GetNetworkLoadBalancersProtocolsOutputArgs struct {
	Filters GetNetworkLoadBalancersProtocolsFilterArrayInput `pulumi:"filters"`
}

A collection of arguments for invoking getNetworkLoadBalancersProtocols.

func (GetNetworkLoadBalancersProtocolsOutputArgs) ElementType 

func (GetNetworkLoadBalancersProtocolsOutputArgs) ElementType() reflect.Type

type GetNetworkLoadBalancersProtocolsResult 

type GetNetworkLoadBalancersProtocolsResult struct {
	Filters []GetNetworkLoadBalancersProtocolsFilter `pulumi:"filters"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// The list of network_load_balancers_protocol_collection.
	NetworkLoadBalancersProtocolCollections []GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollection `pulumi:"networkLoadBalancersProtocolCollections"`
}

A collection of values returned by getNetworkLoadBalancersProtocols.

func GetNetworkLoadBalancersProtocols 

func GetNetworkLoadBalancersProtocols(ctx *pulumi.Context, args *GetNetworkLoadBalancersProtocolsArgs, opts ...pulumi.InvokeOption) (*GetNetworkLoadBalancersProtocolsResult, error)

This data source provides the list of Network Load Balancers Protocols in Oracle Cloud Infrastructure Network Load Balancer service.

This API has been deprecated so it won't return the updated list of supported protocls. Lists all supported traffic protocols.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-oci/sdk/v2/go/oci/NetworkLoadBalancer"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := NetworkLoadBalancer.GetNetworkLoadBalancersProtocols(ctx, nil, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type GetNetworkLoadBalancersProtocolsResultOutput 

type GetNetworkLoadBalancersProtocolsResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getNetworkLoadBalancersProtocols.

func GetNetworkLoadBalancersProtocolsOutput 

func GetNetworkLoadBalancersProtocolsOutput(ctx *pulumi.Context, args GetNetworkLoadBalancersProtocolsOutputArgs, opts ...pulumi.InvokeOption) GetNetworkLoadBalancersProtocolsResultOutput

func (GetNetworkLoadBalancersProtocolsResultOutput) ElementType 

func (GetNetworkLoadBalancersProtocolsResultOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancersProtocolsResultOutput) Filters 

func (o GetNetworkLoadBalancersProtocolsResultOutput) Filters() GetNetworkLoadBalancersProtocolsFilterArrayOutput

func (GetNetworkLoadBalancersProtocolsResultOutput) Id 

func (o GetNetworkLoadBalancersProtocolsResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (GetNetworkLoadBalancersProtocolsResultOutput) NetworkLoadBalancersProtocolCollections 

func (o GetNetworkLoadBalancersProtocolsResultOutput) NetworkLoadBalancersProtocolCollections() GetNetworkLoadBalancersProtocolsNetworkLoadBalancersProtocolCollectionArrayOutput

The list of network_load_balancers_protocol_collection.

func (GetNetworkLoadBalancersProtocolsResultOutput) ToGetNetworkLoadBalancersProtocolsResultOutput 

func (o GetNetworkLoadBalancersProtocolsResultOutput) ToGetNetworkLoadBalancersProtocolsResultOutput() GetNetworkLoadBalancersProtocolsResultOutput

func (GetNetworkLoadBalancersProtocolsResultOutput) ToGetNetworkLoadBalancersProtocolsResultOutputWithContext 

func (o GetNetworkLoadBalancersProtocolsResultOutput) ToGetNetworkLoadBalancersProtocolsResultOutputWithContext(ctx context.Context) GetNetworkLoadBalancersProtocolsResultOutput

type GetNetworkLoadBalancersResult 

type GetNetworkLoadBalancersResult struct {
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the compartment containing the network load balancer.
	CompartmentId string `pulumi:"compartmentId"`
	// A user-friendly name, which does not have to be unique, and can be changed.  Example: `exampleLoadBalancer`
	DisplayName *string                         `pulumi:"displayName"`
	Filters     []GetNetworkLoadBalancersFilter `pulumi:"filters"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// The list of network_load_balancer_collection.
	NetworkLoadBalancerCollections []GetNetworkLoadBalancersNetworkLoadBalancerCollection `pulumi:"networkLoadBalancerCollections"`
	// The current state of the network load balancer.
	State *string `pulumi:"state"`
}

A collection of values returned by getNetworkLoadBalancers.

func GetNetworkLoadBalancers 

func GetNetworkLoadBalancers(ctx *pulumi.Context, args *GetNetworkLoadBalancersArgs, opts ...pulumi.InvokeOption) (*GetNetworkLoadBalancersResult, error)

This data source provides the list of Network Load Balancers in Oracle Cloud Infrastructure Network Load Balancer service.

Returns a list of network load balancers.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-oci/sdk/v2/go/oci/NetworkLoadBalancer"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := NetworkLoadBalancer.GetNetworkLoadBalancers(ctx, &networkloadbalancer.GetNetworkLoadBalancersArgs{
			CompartmentId: compartmentId,
			DisplayName:   pulumi.StringRef(networkLoadBalancerDisplayName),
			State:         pulumi.StringRef(networkLoadBalancerState),
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type GetNetworkLoadBalancersResultOutput 

type GetNetworkLoadBalancersResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getNetworkLoadBalancers.

func GetNetworkLoadBalancersOutput 

func GetNetworkLoadBalancersOutput(ctx *pulumi.Context, args GetNetworkLoadBalancersOutputArgs, opts ...pulumi.InvokeOption) GetNetworkLoadBalancersResultOutput

func (GetNetworkLoadBalancersResultOutput) CompartmentId 

func (o GetNetworkLoadBalancersResultOutput) CompartmentId() pulumi.StringOutput

The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the compartment containing the network load balancer.

func (GetNetworkLoadBalancersResultOutput) DisplayName 

func (o GetNetworkLoadBalancersResultOutput) DisplayName() pulumi.StringPtrOutput

A user-friendly name, which does not have to be unique, and can be changed. Example: `exampleLoadBalancer`

func (GetNetworkLoadBalancersResultOutput) ElementType 

func (GetNetworkLoadBalancersResultOutput) ElementType() reflect.Type

func (GetNetworkLoadBalancersResultOutput) Filters 

func (o GetNetworkLoadBalancersResultOutput) Filters() GetNetworkLoadBalancersFilterArrayOutput

func (GetNetworkLoadBalancersResultOutput) Id 

func (o GetNetworkLoadBalancersResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (GetNetworkLoadBalancersResultOutput) NetworkLoadBalancerCollections 

func (o GetNetworkLoadBalancersResultOutput) NetworkLoadBalancerCollections() GetNetworkLoadBalancersNetworkLoadBalancerCollectionArrayOutput

The list of network_load_balancer_collection.

func (GetNetworkLoadBalancersResultOutput) State 

func (o GetNetworkLoadBalancersResultOutput) State() pulumi.StringPtrOutput

The current state of the network load balancer.

func (GetNetworkLoadBalancersResultOutput) ToGetNetworkLoadBalancersResultOutput 

func (o GetNetworkLoadBalancersResultOutput) ToGetNetworkLoadBalancersResultOutput() GetNetworkLoadBalancersResultOutput

func (GetNetworkLoadBalancersResultOutput) ToGetNetworkLoadBalancersResultOutputWithContext 

func (o GetNetworkLoadBalancersResultOutput) ToGetNetworkLoadBalancersResultOutputWithContext(ctx context.Context) GetNetworkLoadBalancersResultOutput

type Listener 

type Listener struct {
	pulumi.CustomResourceState

	// (Updatable) The name of the associated backend set.  Example: `exampleBackendSet`
	DefaultBackendSetName pulumi.StringOutput `pulumi:"defaultBackendSetName"`
	// (Updatable) IP version associated with the listener.
	IpVersion pulumi.StringOutput `pulumi:"ipVersion"`
	// (Updatable) Property to enable/disable PPv2 feature for this listener.
	IsPpv2enabled pulumi.BoolOutput `pulumi:"isPpv2enabled"`
	// A friendly name for the listener. It must be unique and it cannot be changed.  Example: `exampleListener`
	Name pulumi.StringOutput `pulumi:"name"`
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId pulumi.StringOutput `pulumi:"networkLoadBalancerId"`
	// (Updatable) The communication port for the listener.  Example: `80`
	Port pulumi.IntOutput `pulumi:"port"`
	// (Updatable) The protocol on which the listener accepts connection requests. For public network load balancers, ANY protocol refers to TCP/UDP with the wildcard port. For private network load balancers, ANY protocol refers to TCP/UDP/ICMP (note that ICMP requires isPreserveSourceDestination to be set to true). "ListNetworkLoadBalancersProtocols" API is deprecated and it will not return the updated values. Use the allowed values for the protocol instead.  Example: `TCP`
	Protocol pulumi.StringOutput `pulumi:"protocol"`
	// (Updatable) The duration for TCP idle timeout in seconds. Example: `300`
	TcpIdleTimeout pulumi.IntOutput `pulumi:"tcpIdleTimeout"`
	// (Updatable) The duration for UDP idle timeout in seconds. Example: `120`
	//
	// ** IMPORTANT **
	// Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
	UdpIdleTimeout pulumi.IntOutput `pulumi:"udpIdleTimeout"`
}

This resource provides the Listener resource in Oracle Cloud Infrastructure Network Load Balancer service.

Adds a listener to a network load balancer.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-oci/sdk/v2/go/oci/NetworkLoadBalancer"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := NetworkLoadBalancer.NewListener(ctx, "test_listener", &NetworkLoadBalancer.ListenerArgs{
			DefaultBackendSetName: pulumi.Any(testBackendSet.Name),
			Name:                  pulumi.Any(listenerName),
			NetworkLoadBalancerId: pulumi.Any(testNetworkLoadBalancer.Id),
			Port:                  pulumi.Any(listenerPort),
			Protocol:              pulumi.Any(listenerProtocol),
			IpVersion:             pulumi.Any(listenerIpVersion),
			IsPpv2enabled:         pulumi.Any(listenerIsPpv2enabled),
			TcpIdleTimeout:        pulumi.Any(listenerTcpIdleTimeout),
			UdpIdleTimeout:        pulumi.Any(listenerUdpIdleTimeout),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Listeners can be imported using the `id`, e.g.

```sh $ pulumi import oci:NetworkLoadBalancer/listener:Listener test_listener "networkLoadBalancers/{networkLoadBalancerId}/listeners/{listenerName}" ```

func GetListener 

func GetListener(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ListenerState, opts ...pulumi.ResourceOption) (*Listener, error)

GetListener gets an existing Listener 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 NewListener 

func NewListener(ctx *pulumi.Context,
	name string, args *ListenerArgs, opts ...pulumi.ResourceOption) (*Listener, error)

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

func (*Listener) ElementType 

func (*Listener) ElementType() reflect.Type

func (*Listener) ToListenerOutput 

func (i *Listener) ToListenerOutput() ListenerOutput

func (*Listener) ToListenerOutputWithContext 

func (i *Listener) ToListenerOutputWithContext(ctx context.Context) ListenerOutput

type ListenerArgs 

type ListenerArgs struct {
	// (Updatable) The name of the associated backend set.  Example: `exampleBackendSet`
	DefaultBackendSetName pulumi.StringInput
	// (Updatable) IP version associated with the listener.
	IpVersion pulumi.StringPtrInput
	// (Updatable) Property to enable/disable PPv2 feature for this listener.
	IsPpv2enabled pulumi.BoolPtrInput
	// A friendly name for the listener. It must be unique and it cannot be changed.  Example: `exampleListener`
	Name pulumi.StringPtrInput
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId pulumi.StringInput
	// (Updatable) The communication port for the listener.  Example: `80`
	Port pulumi.IntInput
	// (Updatable) The protocol on which the listener accepts connection requests. For public network load balancers, ANY protocol refers to TCP/UDP with the wildcard port. For private network load balancers, ANY protocol refers to TCP/UDP/ICMP (note that ICMP requires isPreserveSourceDestination to be set to true). "ListNetworkLoadBalancersProtocols" API is deprecated and it will not return the updated values. Use the allowed values for the protocol instead.  Example: `TCP`
	Protocol pulumi.StringInput
	// (Updatable) The duration for TCP idle timeout in seconds. Example: `300`
	TcpIdleTimeout pulumi.IntPtrInput
	// (Updatable) The duration for UDP idle timeout in seconds. Example: `120`
	//
	// ** IMPORTANT **
	// Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
	UdpIdleTimeout pulumi.IntPtrInput
}

The set of arguments for constructing a Listener resource.

func (ListenerArgs) ElementType 

func (ListenerArgs) ElementType() reflect.Type

type ListenerArray 

type ListenerArray []ListenerInput

func (ListenerArray) ElementType 

func (ListenerArray) ElementType() reflect.Type

func (ListenerArray) ToListenerArrayOutput 

func (i ListenerArray) ToListenerArrayOutput() ListenerArrayOutput

func (ListenerArray) ToListenerArrayOutputWithContext 

func (i ListenerArray) ToListenerArrayOutputWithContext(ctx context.Context) ListenerArrayOutput

type ListenerArrayInput 

type ListenerArrayInput interface {
	pulumi.Input

	ToListenerArrayOutput() ListenerArrayOutput
	ToListenerArrayOutputWithContext(context.Context) ListenerArrayOutput
}

ListenerArrayInput is an input type that accepts ListenerArray and ListenerArrayOutput values. You can construct a concrete instance of `ListenerArrayInput` via: 

ListenerArray{ ListenerArgs{...} }

type ListenerArrayOutput 

type ListenerArrayOutput struct{ *pulumi.OutputState }

func (ListenerArrayOutput) ElementType 

func (ListenerArrayOutput) ElementType() reflect.Type

func (ListenerArrayOutput) Index 

func (o ListenerArrayOutput) Index(i pulumi.IntInput) ListenerOutput

func (ListenerArrayOutput) ToListenerArrayOutput 

func (o ListenerArrayOutput) ToListenerArrayOutput() ListenerArrayOutput

func (ListenerArrayOutput) ToListenerArrayOutputWithContext 

func (o ListenerArrayOutput) ToListenerArrayOutputWithContext(ctx context.Context) ListenerArrayOutput

type ListenerInput 

type ListenerInput interface {
	pulumi.Input

	ToListenerOutput() ListenerOutput
	ToListenerOutputWithContext(ctx context.Context) ListenerOutput
}

type ListenerMap 

type ListenerMap map[string]ListenerInput

func (ListenerMap) ElementType 

func (ListenerMap) ElementType() reflect.Type

func (ListenerMap) ToListenerMapOutput 

func (i ListenerMap) ToListenerMapOutput() ListenerMapOutput

func (ListenerMap) ToListenerMapOutputWithContext 

func (i ListenerMap) ToListenerMapOutputWithContext(ctx context.Context) ListenerMapOutput

type ListenerMapInput 

type ListenerMapInput interface {
	pulumi.Input

	ToListenerMapOutput() ListenerMapOutput
	ToListenerMapOutputWithContext(context.Context) ListenerMapOutput
}

ListenerMapInput is an input type that accepts ListenerMap and ListenerMapOutput values. You can construct a concrete instance of `ListenerMapInput` via: 

ListenerMap{ "key": ListenerArgs{...} }

type ListenerMapOutput 

type ListenerMapOutput struct{ *pulumi.OutputState }

func (ListenerMapOutput) ElementType 

func (ListenerMapOutput) ElementType() reflect.Type

func (ListenerMapOutput) MapIndex 

func (o ListenerMapOutput) MapIndex(k pulumi.StringInput) ListenerOutput

func (ListenerMapOutput) ToListenerMapOutput 

func (o ListenerMapOutput) ToListenerMapOutput() ListenerMapOutput

func (ListenerMapOutput) ToListenerMapOutputWithContext 

func (o ListenerMapOutput) ToListenerMapOutputWithContext(ctx context.Context) ListenerMapOutput

type ListenerOutput 

type ListenerOutput struct{ *pulumi.OutputState }

func (ListenerOutput) DefaultBackendSetName 

func (o ListenerOutput) DefaultBackendSetName() pulumi.StringOutput

(Updatable) The name of the associated backend set. Example: `exampleBackendSet`

func (ListenerOutput) ElementType 

func (ListenerOutput) ElementType() reflect.Type

func (ListenerOutput) IpVersion 

func (o ListenerOutput) IpVersion() pulumi.StringOutput

(Updatable) IP version associated with the listener.

func (ListenerOutput) IsPpv2enabled 

func (o ListenerOutput) IsPpv2enabled() pulumi.BoolOutput

(Updatable) Property to enable/disable PPv2 feature for this listener.

func (ListenerOutput) Name 

func (o ListenerOutput) Name() pulumi.StringOutput

A friendly name for the listener. It must be unique and it cannot be changed. Example: `exampleListener`

func (ListenerOutput) NetworkLoadBalancerId 

func (o ListenerOutput) NetworkLoadBalancerId() pulumi.StringOutput

The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.

func (ListenerOutput) Port 

func (o ListenerOutput) Port() pulumi.IntOutput

(Updatable) The communication port for the listener. Example: `80`

func (ListenerOutput) Protocol 

func (o ListenerOutput) Protocol() pulumi.StringOutput

(Updatable) The protocol on which the listener accepts connection requests. For public network load balancers, ANY protocol refers to TCP/UDP with the wildcard port. For private network load balancers, ANY protocol refers to TCP/UDP/ICMP (note that ICMP requires isPreserveSourceDestination to be set to true). "ListNetworkLoadBalancersProtocols" API is deprecated and it will not return the updated values. Use the allowed values for the protocol instead. Example: `TCP`

func (ListenerOutput) TcpIdleTimeout added in v2.7.0 

func (o ListenerOutput) TcpIdleTimeout() pulumi.IntOutput

(Updatable) The duration for TCP idle timeout in seconds. Example: `300`

func (ListenerOutput) ToListenerOutput 

func (o ListenerOutput) ToListenerOutput() ListenerOutput

func (ListenerOutput) ToListenerOutputWithContext 

func (o ListenerOutput) ToListenerOutputWithContext(ctx context.Context) ListenerOutput

func (ListenerOutput) UdpIdleTimeout added in v2.7.0 

func (o ListenerOutput) UdpIdleTimeout() pulumi.IntOutput

(Updatable) The duration for UDP idle timeout in seconds. Example: `120`

** IMPORTANT ** Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values

type ListenerState 

type ListenerState struct {
	// (Updatable) The name of the associated backend set.  Example: `exampleBackendSet`
	DefaultBackendSetName pulumi.StringPtrInput
	// (Updatable) IP version associated with the listener.
	IpVersion pulumi.StringPtrInput
	// (Updatable) Property to enable/disable PPv2 feature for this listener.
	IsPpv2enabled pulumi.BoolPtrInput
	// A friendly name for the listener. It must be unique and it cannot be changed.  Example: `exampleListener`
	Name pulumi.StringPtrInput
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId pulumi.StringPtrInput
	// (Updatable) The communication port for the listener.  Example: `80`
	Port pulumi.IntPtrInput
	// (Updatable) The protocol on which the listener accepts connection requests. For public network load balancers, ANY protocol refers to TCP/UDP with the wildcard port. For private network load balancers, ANY protocol refers to TCP/UDP/ICMP (note that ICMP requires isPreserveSourceDestination to be set to true). "ListNetworkLoadBalancersProtocols" API is deprecated and it will not return the updated values. Use the allowed values for the protocol instead.  Example: `TCP`
	Protocol pulumi.StringPtrInput
	// (Updatable) The duration for TCP idle timeout in seconds. Example: `300`
	TcpIdleTimeout pulumi.IntPtrInput
	// (Updatable) The duration for UDP idle timeout in seconds. Example: `120`
	//
	// ** IMPORTANT **
	// Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
	UdpIdleTimeout pulumi.IntPtrInput
}

func (ListenerState) ElementType 

func (ListenerState) ElementType() reflect.Type

type LookupBackendSetArgs 

type LookupBackendSetArgs struct {
	// The name of the backend set to retrieve.  Example: `exampleBackendSet`
	BackendSetName string `pulumi:"backendSetName"`
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId string `pulumi:"networkLoadBalancerId"`
}

A collection of arguments for invoking getBackendSet.

type LookupBackendSetOutputArgs 

type LookupBackendSetOutputArgs struct {
	// The name of the backend set to retrieve.  Example: `exampleBackendSet`
	BackendSetName pulumi.StringInput `pulumi:"backendSetName"`
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId pulumi.StringInput `pulumi:"networkLoadBalancerId"`
}

A collection of arguments for invoking getBackendSet.

func (LookupBackendSetOutputArgs) ElementType 

func (LookupBackendSetOutputArgs) ElementType() reflect.Type

type LookupBackendSetResult 

type LookupBackendSetResult struct {
	BackendSetName string `pulumi:"backendSetName"`
	// Array of backends.
	Backends []GetBackendSetBackend `pulumi:"backends"`
	// The health check policy configuration. For more information, see [Editing Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/Balance/Tasks/editinghealthcheck.htm).
	HealthCheckers []GetBackendSetHealthChecker `pulumi:"healthCheckers"`
	Id             string                       `pulumi:"id"`
	// IP version associated with the backend set.
	IpVersion string `pulumi:"ipVersion"`
	// If enabled, the network load balancer will continue to distribute traffic in the configured distribution in the event all backends are unhealthy. The value is false by default.
	IsFailOpen bool `pulumi:"isFailOpen"`
	// If enabled existing connections will be forwarded to an alternative healthy backend as soon as current backend becomes unhealthy.
	IsInstantFailoverEnabled bool `pulumi:"isInstantFailoverEnabled"`
	// If this parameter is enabled, then the network load balancer preserves the source IP of the packet when it is forwarded to backends. Backends see the original source IP. If the isPreserveSourceDestination parameter is enabled for the network load balancer resource, then this parameter cannot be disabled. The value is true by default.
	IsPreserveSource bool `pulumi:"isPreserveSource"`
	// A user-friendly name for the backend set that must be unique and cannot be changed.
	Name                  string `pulumi:"name"`
	NetworkLoadBalancerId string `pulumi:"networkLoadBalancerId"`
	// The network load balancer policy for the backend set.  Example: `FIVE_TUPLE`
	Policy string `pulumi:"policy"`
}

A collection of values returned by getBackendSet.

func LookupBackendSet 

func LookupBackendSet(ctx *pulumi.Context, args *LookupBackendSetArgs, opts ...pulumi.InvokeOption) (*LookupBackendSetResult, error)

This data source provides details about a specific Backend Set resource in Oracle Cloud Infrastructure Network Load Balancer service.

Retrieves the configuration information for the specified backend set.

type LookupBackendSetResultOutput 

type LookupBackendSetResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getBackendSet.

func LookupBackendSetOutput 

func LookupBackendSetOutput(ctx *pulumi.Context, args LookupBackendSetOutputArgs, opts ...pulumi.InvokeOption) LookupBackendSetResultOutput

func (LookupBackendSetResultOutput) BackendSetName 

func (o LookupBackendSetResultOutput) BackendSetName() pulumi.StringOutput

func (LookupBackendSetResultOutput) Backends 

func (o LookupBackendSetResultOutput) Backends() GetBackendSetBackendArrayOutput

Array of backends.

func (LookupBackendSetResultOutput) ElementType 

func (LookupBackendSetResultOutput) ElementType() reflect.Type

func (LookupBackendSetResultOutput) HealthCheckers 

func (o LookupBackendSetResultOutput) HealthCheckers() GetBackendSetHealthCheckerArrayOutput

The health check policy configuration. For more information, see [Editing Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/Balance/Tasks/editinghealthcheck.htm).

func (LookupBackendSetResultOutput) Id 

func (o LookupBackendSetResultOutput) Id() pulumi.StringOutput

func (LookupBackendSetResultOutput) IpVersion 

func (o LookupBackendSetResultOutput) IpVersion() pulumi.StringOutput

IP version associated with the backend set.

func (LookupBackendSetResultOutput) IsFailOpen 

func (o LookupBackendSetResultOutput) IsFailOpen() pulumi.BoolOutput

If enabled, the network load balancer will continue to distribute traffic in the configured distribution in the event all backends are unhealthy. The value is false by default.

func (LookupBackendSetResultOutput) IsInstantFailoverEnabled 

func (o LookupBackendSetResultOutput) IsInstantFailoverEnabled() pulumi.BoolOutput

If enabled existing connections will be forwarded to an alternative healthy backend as soon as current backend becomes unhealthy.

func (LookupBackendSetResultOutput) IsPreserveSource 

func (o LookupBackendSetResultOutput) IsPreserveSource() pulumi.BoolOutput

If this parameter is enabled, then the network load balancer preserves the source IP of the packet when it is forwarded to backends. Backends see the original source IP. If the isPreserveSourceDestination parameter is enabled for the network load balancer resource, then this parameter cannot be disabled. The value is true by default.

func (LookupBackendSetResultOutput) Name 

func (o LookupBackendSetResultOutput) Name() pulumi.StringOutput

A user-friendly name for the backend set that must be unique and cannot be changed.

func (LookupBackendSetResultOutput) NetworkLoadBalancerId 

func (o LookupBackendSetResultOutput) NetworkLoadBalancerId() pulumi.StringOutput

func (LookupBackendSetResultOutput) Policy 

func (o LookupBackendSetResultOutput) Policy() pulumi.StringOutput

The network load balancer policy for the backend set. Example: `FIVE_TUPLE`

func (LookupBackendSetResultOutput) ToLookupBackendSetResultOutput 

func (o LookupBackendSetResultOutput) ToLookupBackendSetResultOutput() LookupBackendSetResultOutput

func (LookupBackendSetResultOutput) ToLookupBackendSetResultOutputWithContext 

func (o LookupBackendSetResultOutput) ToLookupBackendSetResultOutputWithContext(ctx context.Context) LookupBackendSetResultOutput

type LookupListenerArgs 

type LookupListenerArgs struct {
	// The name of the listener to get.  Example: `exampleListener`
	ListenerName string `pulumi:"listenerName"`
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId string `pulumi:"networkLoadBalancerId"`
}

A collection of arguments for invoking getListener.

type LookupListenerOutputArgs 

type LookupListenerOutputArgs struct {
	// The name of the listener to get.  Example: `exampleListener`
	ListenerName pulumi.StringInput `pulumi:"listenerName"`
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId pulumi.StringInput `pulumi:"networkLoadBalancerId"`
}

A collection of arguments for invoking getListener.

func (LookupListenerOutputArgs) ElementType 

func (LookupListenerOutputArgs) ElementType() reflect.Type

type LookupListenerResult 

type LookupListenerResult struct {
	// The name of the associated backend set.  Example: `exampleBackendSet`
	DefaultBackendSetName string `pulumi:"defaultBackendSetName"`
	Id                    string `pulumi:"id"`
	// IP version associated with the listener.
	IpVersion string `pulumi:"ipVersion"`
	// Property to enable/disable PPv2 feature for this listener.
	IsPpv2enabled bool   `pulumi:"isPpv2enabled"`
	ListenerName  string `pulumi:"listenerName"`
	// A friendly name for the listener. It must be unique and it cannot be changed.  Example: `exampleListener`
	Name                  string `pulumi:"name"`
	NetworkLoadBalancerId string `pulumi:"networkLoadBalancerId"`
	// The communication port for the listener.  Example: `80`
	Port int `pulumi:"port"`
	// The protocol on which the listener accepts connection requests. For public network load balancers, ANY protocol refers to TCP/UDP with the wildcard port. For private network load balancers, ANY protocol refers to TCP/UDP/ICMP (note that ICMP requires isPreserveSourceDestination to be set to true). "ListNetworkLoadBalancersProtocols" API is deprecated and it will not return the updated values. Use the allowed values for the protocol instead.  Example: `TCP`
	Protocol string `pulumi:"protocol"`
	// The duration for TCP idle timeout in seconds. Example: `300`
	TcpIdleTimeout int `pulumi:"tcpIdleTimeout"`
	// The duration for UDP idle timeout in seconds. Example: `120`
	UdpIdleTimeout int `pulumi:"udpIdleTimeout"`
}

A collection of values returned by getListener.

func LookupListener 

func LookupListener(ctx *pulumi.Context, args *LookupListenerArgs, opts ...pulumi.InvokeOption) (*LookupListenerResult, error)

This data source provides details about a specific Listener resource in Oracle Cloud Infrastructure Network Load Balancer service.

Retrieves listener properties associated with a given network load balancer and listener name.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-oci/sdk/v2/go/oci/NetworkLoadBalancer"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := NetworkLoadBalancer.GetListener(ctx, &networkloadbalancer.GetListenerArgs{
			ListenerName:          testListenerOciNetworkLoadBalancerListener.Name,
			NetworkLoadBalancerId: testNetworkLoadBalancer.Id,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupListenerResultOutput 

type LookupListenerResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getListener.

func LookupListenerOutput 

func LookupListenerOutput(ctx *pulumi.Context, args LookupListenerOutputArgs, opts ...pulumi.InvokeOption) LookupListenerResultOutput

func (LookupListenerResultOutput) DefaultBackendSetName 

func (o LookupListenerResultOutput) DefaultBackendSetName() pulumi.StringOutput

The name of the associated backend set. Example: `exampleBackendSet`

func (LookupListenerResultOutput) ElementType 

func (LookupListenerResultOutput) ElementType() reflect.Type

func (LookupListenerResultOutput) Id 

func (o LookupListenerResultOutput) Id() pulumi.StringOutput

func (LookupListenerResultOutput) IpVersion 

func (o LookupListenerResultOutput) IpVersion() pulumi.StringOutput

IP version associated with the listener.

func (LookupListenerResultOutput) IsPpv2enabled 

func (o LookupListenerResultOutput) IsPpv2enabled() pulumi.BoolOutput

Property to enable/disable PPv2 feature for this listener.

func (LookupListenerResultOutput) ListenerName 

func (o LookupListenerResultOutput) ListenerName() pulumi.StringOutput

func (LookupListenerResultOutput) Name 

func (o LookupListenerResultOutput) Name() pulumi.StringOutput

A friendly name for the listener. It must be unique and it cannot be changed. Example: `exampleListener`

func (LookupListenerResultOutput) NetworkLoadBalancerId 

func (o LookupListenerResultOutput) NetworkLoadBalancerId() pulumi.StringOutput

func (LookupListenerResultOutput) Port 

func (o LookupListenerResultOutput) Port() pulumi.IntOutput

The communication port for the listener. Example: `80`

func (LookupListenerResultOutput) Protocol 

func (o LookupListenerResultOutput) Protocol() pulumi.StringOutput

The protocol on which the listener accepts connection requests. For public network load balancers, ANY protocol refers to TCP/UDP with the wildcard port. For private network load balancers, ANY protocol refers to TCP/UDP/ICMP (note that ICMP requires isPreserveSourceDestination to be set to true). "ListNetworkLoadBalancersProtocols" API is deprecated and it will not return the updated values. Use the allowed values for the protocol instead. Example: `TCP`

func (LookupListenerResultOutput) TcpIdleTimeout added in v2.7.0 

func (o LookupListenerResultOutput) TcpIdleTimeout() pulumi.IntOutput

The duration for TCP idle timeout in seconds. Example: `300`

func (LookupListenerResultOutput) ToLookupListenerResultOutput 

func (o LookupListenerResultOutput) ToLookupListenerResultOutput() LookupListenerResultOutput

func (LookupListenerResultOutput) ToLookupListenerResultOutputWithContext 

func (o LookupListenerResultOutput) ToLookupListenerResultOutputWithContext(ctx context.Context) LookupListenerResultOutput

func (LookupListenerResultOutput) UdpIdleTimeout added in v2.7.0 

func (o LookupListenerResultOutput) UdpIdleTimeout() pulumi.IntOutput

The duration for UDP idle timeout in seconds. Example: `120`

type LookupNetworkLoadBalancerArgs 

type LookupNetworkLoadBalancerArgs struct {
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId string `pulumi:"networkLoadBalancerId"`
}

A collection of arguments for invoking getNetworkLoadBalancer.

type LookupNetworkLoadBalancerOutputArgs 

type LookupNetworkLoadBalancerOutputArgs struct {
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId pulumi.StringInput `pulumi:"networkLoadBalancerId"`
}

A collection of arguments for invoking getNetworkLoadBalancer.

func (LookupNetworkLoadBalancerOutputArgs) ElementType 

func (LookupNetworkLoadBalancerOutputArgs) ElementType() reflect.Type

type LookupNetworkLoadBalancerResult 

type LookupNetworkLoadBalancerResult struct {
	AssignedIpv6        string `pulumi:"assignedIpv6"`
	AssignedPrivateIpv4 string `pulumi:"assignedPrivateIpv4"`
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the compartment containing the network load balancer.
	CompartmentId string `pulumi:"compartmentId"`
	// Defined tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm).  Example: `{"Operations.CostCenter": "42"}`
	DefinedTags map[string]string `pulumi:"definedTags"`
	// A user-friendly name, which does not have to be unique, and can be changed.  Example: `exampleLoadBalancer`
	DisplayName string `pulumi:"displayName"`
	// Free-form tags for this resource. Each tag is a simple key-value pair with no predefined name, type, or namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm).  Example: `{"Department": "Finance"}`
	FreeformTags map[string]string `pulumi:"freeformTags"`
	// OCID of the reserved public IP address created with the virtual cloud network.
	Id string `pulumi:"id"`
	// An array of IP addresses.
	IpAddresses []GetNetworkLoadBalancerIpAddress `pulumi:"ipAddresses"`
	// When enabled, the skipSourceDestinationCheck parameter is automatically enabled on the load balancer VNIC. Packets are sent to the backend set without any changes to the source and destination IP.
	IsPreserveSourceDestination bool `pulumi:"isPreserveSourceDestination"`
	// Whether the network load balancer has a virtual cloud network-local (private) IP address.
	IsPrivate bool `pulumi:"isPrivate"`
	// This can only be enabled when NLB is working in transparent mode with source destination header preservation enabled.  This removes the additional dependency from NLB backends(like Firewalls) to perform SNAT.
	IsSymmetricHashEnabled bool `pulumi:"isSymmetricHashEnabled"`
	// A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
	LifecycleDetails      string `pulumi:"lifecycleDetails"`
	NetworkLoadBalancerId string `pulumi:"networkLoadBalancerId"`
	// An array of network security groups [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) associated with the network load balancer.
	NetworkSecurityGroupIds []string `pulumi:"networkSecurityGroupIds"`
	// IP version associated with the NLB.
	NlbIpVersion string                             `pulumi:"nlbIpVersion"`
	ReservedIps  []GetNetworkLoadBalancerReservedIp `pulumi:"reservedIps"`
	// The current state of the network load balancer.
	State string `pulumi:"state"`
	// The subnet in which the network load balancer is spawned [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm)."
	SubnetId       string `pulumi:"subnetId"`
	SubnetIpv6cidr string `pulumi:"subnetIpv6cidr"`
	// Key-value pair representing system tags' keys and values scoped to a namespace. Example: `{"bar-key": "value"}`
	SystemTags map[string]string `pulumi:"systemTags"`
	// The date and time the network load balancer was created, in the format defined by RFC3339.  Example: `2020-05-01T21:10:29.600Z`
	TimeCreated string `pulumi:"timeCreated"`
	// The time the network load balancer was updated. An RFC3339 formatted date-time string.  Example: `2020-05-01T22:10:29.600Z`
	TimeUpdated string `pulumi:"timeUpdated"`
}

A collection of values returned by getNetworkLoadBalancer.

func LookupNetworkLoadBalancer 

func LookupNetworkLoadBalancer(ctx *pulumi.Context, args *LookupNetworkLoadBalancerArgs, opts ...pulumi.InvokeOption) (*LookupNetworkLoadBalancerResult, error)

This data source provides details about a specific Network Load Balancer resource in Oracle Cloud Infrastructure Network Load Balancer service.

Retrieves network load balancer configuration information by identifier.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-oci/sdk/v2/go/oci/NetworkLoadBalancer"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := NetworkLoadBalancer.GetNetworkLoadBalancer(ctx, &networkloadbalancer.GetNetworkLoadBalancerArgs{
			NetworkLoadBalancerId: testNetworkLoadBalancerOciNetworkLoadBalancerNetworkLoadBalancer.Id,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupNetworkLoadBalancerResultOutput 

type LookupNetworkLoadBalancerResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getNetworkLoadBalancer.

func LookupNetworkLoadBalancerOutput 

func LookupNetworkLoadBalancerOutput(ctx *pulumi.Context, args LookupNetworkLoadBalancerOutputArgs, opts ...pulumi.InvokeOption) LookupNetworkLoadBalancerResultOutput

func (LookupNetworkLoadBalancerResultOutput) AssignedIpv6 

func (o LookupNetworkLoadBalancerResultOutput) AssignedIpv6() pulumi.StringOutput

func (LookupNetworkLoadBalancerResultOutput) AssignedPrivateIpv4 

func (o LookupNetworkLoadBalancerResultOutput) AssignedPrivateIpv4() pulumi.StringOutput

func (LookupNetworkLoadBalancerResultOutput) CompartmentId 

func (o LookupNetworkLoadBalancerResultOutput) CompartmentId() pulumi.StringOutput

The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the compartment containing the network load balancer.

func (LookupNetworkLoadBalancerResultOutput) DefinedTags 

func (o LookupNetworkLoadBalancerResultOutput) DefinedTags() pulumi.StringMapOutput

Defined tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm). Example: `{"Operations.CostCenter": "42"}`

func (LookupNetworkLoadBalancerResultOutput) DisplayName 

func (o LookupNetworkLoadBalancerResultOutput) DisplayName() pulumi.StringOutput

A user-friendly name, which does not have to be unique, and can be changed. Example: `exampleLoadBalancer`

func (LookupNetworkLoadBalancerResultOutput) ElementType 

func (LookupNetworkLoadBalancerResultOutput) ElementType() reflect.Type

func (LookupNetworkLoadBalancerResultOutput) FreeformTags 

func (o LookupNetworkLoadBalancerResultOutput) FreeformTags() pulumi.StringMapOutput

Free-form tags for this resource. Each tag is a simple key-value pair with no predefined name, type, or namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm). Example: `{"Department": "Finance"}`

func (LookupNetworkLoadBalancerResultOutput) Id 

func (o LookupNetworkLoadBalancerResultOutput) Id() pulumi.StringOutput

OCID of the reserved public IP address created with the virtual cloud network.

func (LookupNetworkLoadBalancerResultOutput) IpAddresses 

func (o LookupNetworkLoadBalancerResultOutput) IpAddresses() GetNetworkLoadBalancerIpAddressArrayOutput

An array of IP addresses.

func (LookupNetworkLoadBalancerResultOutput) IsPreserveSourceDestination 

func (o LookupNetworkLoadBalancerResultOutput) IsPreserveSourceDestination() pulumi.BoolOutput

When enabled, the skipSourceDestinationCheck parameter is automatically enabled on the load balancer VNIC. Packets are sent to the backend set without any changes to the source and destination IP.

func (LookupNetworkLoadBalancerResultOutput) IsPrivate 

func (o LookupNetworkLoadBalancerResultOutput) IsPrivate() pulumi.BoolOutput

Whether the network load balancer has a virtual cloud network-local (private) IP address.

func (LookupNetworkLoadBalancerResultOutput) IsSymmetricHashEnabled 

func (o LookupNetworkLoadBalancerResultOutput) IsSymmetricHashEnabled() pulumi.BoolOutput

This can only be enabled when NLB is working in transparent mode with source destination header preservation enabled. This removes the additional dependency from NLB backends(like Firewalls) to perform SNAT.

func (LookupNetworkLoadBalancerResultOutput) LifecycleDetails 

func (o LookupNetworkLoadBalancerResultOutput) LifecycleDetails() pulumi.StringOutput

A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.

func (LookupNetworkLoadBalancerResultOutput) NetworkLoadBalancerId 

func (o LookupNetworkLoadBalancerResultOutput) NetworkLoadBalancerId() pulumi.StringOutput

func (LookupNetworkLoadBalancerResultOutput) NetworkSecurityGroupIds 

func (o LookupNetworkLoadBalancerResultOutput) NetworkSecurityGroupIds() pulumi.StringArrayOutput

An array of network security groups [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) associated with the network load balancer.

func (LookupNetworkLoadBalancerResultOutput) NlbIpVersion 

func (o LookupNetworkLoadBalancerResultOutput) NlbIpVersion() pulumi.StringOutput

IP version associated with the NLB.

func (LookupNetworkLoadBalancerResultOutput) ReservedIps 

func (o LookupNetworkLoadBalancerResultOutput) ReservedIps() GetNetworkLoadBalancerReservedIpArrayOutput

func (LookupNetworkLoadBalancerResultOutput) State 

func (o LookupNetworkLoadBalancerResultOutput) State() pulumi.StringOutput

The current state of the network load balancer.

func (LookupNetworkLoadBalancerResultOutput) SubnetId 

func (o LookupNetworkLoadBalancerResultOutput) SubnetId() pulumi.StringOutput

The subnet in which the network load balancer is spawned [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm)."

func (LookupNetworkLoadBalancerResultOutput) SubnetIpv6cidr 

func (o LookupNetworkLoadBalancerResultOutput) SubnetIpv6cidr() pulumi.StringOutput

func (LookupNetworkLoadBalancerResultOutput) SystemTags 

func (o LookupNetworkLoadBalancerResultOutput) SystemTags() pulumi.StringMapOutput

Key-value pair representing system tags' keys and values scoped to a namespace. Example: `{"bar-key": "value"}`

func (LookupNetworkLoadBalancerResultOutput) TimeCreated 

func (o LookupNetworkLoadBalancerResultOutput) TimeCreated() pulumi.StringOutput

The date and time the network load balancer was created, in the format defined by RFC3339. Example: `2020-05-01T21:10:29.600Z`

func (LookupNetworkLoadBalancerResultOutput) TimeUpdated 

func (o LookupNetworkLoadBalancerResultOutput) TimeUpdated() pulumi.StringOutput

The time the network load balancer was updated. An RFC3339 formatted date-time string. Example: `2020-05-01T22:10:29.600Z`

func (LookupNetworkLoadBalancerResultOutput) ToLookupNetworkLoadBalancerResultOutput 

func (o LookupNetworkLoadBalancerResultOutput) ToLookupNetworkLoadBalancerResultOutput() LookupNetworkLoadBalancerResultOutput

func (LookupNetworkLoadBalancerResultOutput) ToLookupNetworkLoadBalancerResultOutputWithContext 

func (o LookupNetworkLoadBalancerResultOutput) ToLookupNetworkLoadBalancerResultOutputWithContext(ctx context.Context) LookupNetworkLoadBalancerResultOutput

type NetworkLoadBalancer 

type NetworkLoadBalancer struct {
	pulumi.CustomResourceState

	// IPv6 address to be assigned to the network load balancer being created. This IP address has to be part of one of the prefixes supported by the subnet. Example: "2607:9b80:9a0a:9a7e:abcd:ef01:2345:6789"
	AssignedIpv6 pulumi.StringPtrOutput `pulumi:"assignedIpv6"`
	// Private IP address to be assigned to the network load balancer being created. This IP address has to be in the CIDR range of the subnet where network load balancer is being created Example: "10.0.0.1"
	AssignedPrivateIpv4 pulumi.StringPtrOutput `pulumi:"assignedPrivateIpv4"`
	// (Updatable) The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the compartment containing the network load balancer.
	CompartmentId pulumi.StringOutput `pulumi:"compartmentId"`
	// (Updatable) Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
	DefinedTags pulumi.StringMapOutput `pulumi:"definedTags"`
	// (Updatable) Network load balancer identifier, which can be renamed.
	DisplayName pulumi.StringOutput `pulumi:"displayName"`
	// (Updatable) Simple key-value pair that is applied without any predefined name, type, or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
	FreeformTags pulumi.StringMapOutput `pulumi:"freeformTags"`
	// An array of IP addresses.
	IpAddresses NetworkLoadBalancerIpAddressArrayOutput `pulumi:"ipAddresses"`
	// (Updatable) This parameter can be enabled only if backends are compute OCIDs. When enabled, the skipSourceDestinationCheck parameter is automatically enabled on the load balancer VNIC, and packets are sent to the backend with the entire IP header intact.
	IsPreserveSourceDestination pulumi.BoolOutput `pulumi:"isPreserveSourceDestination"`
	// Whether the network load balancer has a virtual cloud network-local (private) IP address.
	//
	// If "true", then the service assigns a private IP address to the network load balancer.
	//
	// If "false", then the service assigns a public IP address to the network load balancer.
	//
	// A public network load balancer is accessible from the internet, depending on the [security list rules](https://docs.cloud.oracle.com/iaas/Content/network/Concepts/securitylists.htm) for your virtual cloud network. For more information about public and private network load balancers, see [How Network Load Balancing Works](https://docs.cloud.oracle.com/iaas/Content/Balance/Concepts/balanceoverview.htm#how-network-load-balancing-works). This value is true by default.
	//
	// Example: `true`
	IsPrivate pulumi.BoolOutput `pulumi:"isPrivate"`
	// (Updatable) This can only be enabled when NLB is working in transparent mode with source destination header preservation enabled.  This removes the additional dependency from NLB backends(like Firewalls) to perform SNAT.
	//
	// Example: `true`
	// Example: `true`
	IsSymmetricHashEnabled pulumi.BoolOutput `pulumi:"isSymmetricHashEnabled"`
	// A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
	LifecycleDetails pulumi.StringOutput `pulumi:"lifecycleDetails"`
	// (Updatable) An array of network security groups [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) associated with the network load balancer.
	//
	// During the creation of the network load balancer, the service adds the new load balancer to the specified network security groups.
	//
	// The benefits of associating the network load balancer with network security groups include:
	// *  Network security groups define network security rules to govern ingress and egress traffic for the network load balancer.
	// *  The network security rules of other resources can reference the network security groups associated with the network load balancer to ensure access.
	//
	// Example: ["ocid1.nsg.oc1.phx.unique_ID"]
	NetworkSecurityGroupIds pulumi.StringArrayOutput `pulumi:"networkSecurityGroupIds"`
	// (Updatable) IP version associated with the NLB.
	NlbIpVersion pulumi.StringOutput `pulumi:"nlbIpVersion"`
	// An array of reserved Ips.
	ReservedIps NetworkLoadBalancerReservedIpArrayOutput `pulumi:"reservedIps"`
	// The current state of the network load balancer.
	State pulumi.StringOutput `pulumi:"state"`
	// The subnet in which the network load balancer is spawned [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
	SubnetId pulumi.StringOutput `pulumi:"subnetId"`
	// IPv6 subnet prefix selection. If Ipv6 subnet prefix is passed, Nlb Ipv6 Address would be assign within the cidr block. NLB has to be dual or single stack ipv6 to support this.
	//
	// ** IMPORTANT **
	// Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
	SubnetIpv6cidr pulumi.StringPtrOutput `pulumi:"subnetIpv6cidr"`
	// Key-value pair representing system tags' keys and values scoped to a namespace. Example: `{"bar-key": "value"}`
	SystemTags pulumi.StringMapOutput `pulumi:"systemTags"`
	// The date and time the network load balancer was created, in the format defined by RFC3339.  Example: `2020-05-01T21:10:29.600Z`
	TimeCreated pulumi.StringOutput `pulumi:"timeCreated"`
	// The time the network load balancer was updated. An RFC3339 formatted date-time string.  Example: `2020-05-01T22:10:29.600Z`
	TimeUpdated pulumi.StringOutput `pulumi:"timeUpdated"`
}

This resource provides the Network Load Balancer resource in Oracle Cloud Infrastructure Network Load Balancer service.

Creates a network load balancer.

## Import

NetworkLoadBalancers can be imported using the `id`, e.g.

```sh $ pulumi import oci:NetworkLoadBalancer/networkLoadBalancer:NetworkLoadBalancer test_network_load_balancer "id" ```

func GetNetworkLoadBalancer 

func GetNetworkLoadBalancer(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *NetworkLoadBalancerState, opts ...pulumi.ResourceOption) (*NetworkLoadBalancer, error)

GetNetworkLoadBalancer gets an existing NetworkLoadBalancer 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 NewNetworkLoadBalancer 

func NewNetworkLoadBalancer(ctx *pulumi.Context,
	name string, args *NetworkLoadBalancerArgs, opts ...pulumi.ResourceOption) (*NetworkLoadBalancer, error)

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

func (*NetworkLoadBalancer) ElementType 

func (*NetworkLoadBalancer) ElementType() reflect.Type

func (*NetworkLoadBalancer) ToNetworkLoadBalancerOutput 

func (i *NetworkLoadBalancer) ToNetworkLoadBalancerOutput() NetworkLoadBalancerOutput

func (*NetworkLoadBalancer) ToNetworkLoadBalancerOutputWithContext 

func (i *NetworkLoadBalancer) ToNetworkLoadBalancerOutputWithContext(ctx context.Context) NetworkLoadBalancerOutput

type NetworkLoadBalancerArgs 

type NetworkLoadBalancerArgs struct {
	// IPv6 address to be assigned to the network load balancer being created. This IP address has to be part of one of the prefixes supported by the subnet. Example: "2607:9b80:9a0a:9a7e:abcd:ef01:2345:6789"
	AssignedIpv6 pulumi.StringPtrInput
	// Private IP address to be assigned to the network load balancer being created. This IP address has to be in the CIDR range of the subnet where network load balancer is being created Example: "10.0.0.1"
	AssignedPrivateIpv4 pulumi.StringPtrInput
	// (Updatable) The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the compartment containing the network load balancer.
	CompartmentId pulumi.StringInput
	// (Updatable) Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
	DefinedTags pulumi.StringMapInput
	// (Updatable) Network load balancer identifier, which can be renamed.
	DisplayName pulumi.StringInput
	// (Updatable) Simple key-value pair that is applied without any predefined name, type, or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
	FreeformTags pulumi.StringMapInput
	// (Updatable) This parameter can be enabled only if backends are compute OCIDs. When enabled, the skipSourceDestinationCheck parameter is automatically enabled on the load balancer VNIC, and packets are sent to the backend with the entire IP header intact.
	IsPreserveSourceDestination pulumi.BoolPtrInput
	// Whether the network load balancer has a virtual cloud network-local (private) IP address.
	//
	// If "true", then the service assigns a private IP address to the network load balancer.
	//
	// If "false", then the service assigns a public IP address to the network load balancer.
	//
	// A public network load balancer is accessible from the internet, depending on the [security list rules](https://docs.cloud.oracle.com/iaas/Content/network/Concepts/securitylists.htm) for your virtual cloud network. For more information about public and private network load balancers, see [How Network Load Balancing Works](https://docs.cloud.oracle.com/iaas/Content/Balance/Concepts/balanceoverview.htm#how-network-load-balancing-works). This value is true by default.
	//
	// Example: `true`
	IsPrivate pulumi.BoolPtrInput
	// (Updatable) This can only be enabled when NLB is working in transparent mode with source destination header preservation enabled.  This removes the additional dependency from NLB backends(like Firewalls) to perform SNAT.
	//
	// Example: `true`
	// Example: `true`
	IsSymmetricHashEnabled pulumi.BoolPtrInput
	// (Updatable) An array of network security groups [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) associated with the network load balancer.
	//
	// During the creation of the network load balancer, the service adds the new load balancer to the specified network security groups.
	//
	// The benefits of associating the network load balancer with network security groups include:
	// *  Network security groups define network security rules to govern ingress and egress traffic for the network load balancer.
	// *  The network security rules of other resources can reference the network security groups associated with the network load balancer to ensure access.
	//
	// Example: ["ocid1.nsg.oc1.phx.unique_ID"]
	NetworkSecurityGroupIds pulumi.StringArrayInput
	// (Updatable) IP version associated with the NLB.
	NlbIpVersion pulumi.StringPtrInput
	// An array of reserved Ips.
	ReservedIps NetworkLoadBalancerReservedIpArrayInput
	// The subnet in which the network load balancer is spawned [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
	SubnetId pulumi.StringInput
	// IPv6 subnet prefix selection. If Ipv6 subnet prefix is passed, Nlb Ipv6 Address would be assign within the cidr block. NLB has to be dual or single stack ipv6 to support this.
	//
	// ** IMPORTANT **
	// Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
	SubnetIpv6cidr pulumi.StringPtrInput
}

The set of arguments for constructing a NetworkLoadBalancer resource.

func (NetworkLoadBalancerArgs) ElementType 

func (NetworkLoadBalancerArgs) ElementType() reflect.Type

type NetworkLoadBalancerArray 

type NetworkLoadBalancerArray []NetworkLoadBalancerInput

func (NetworkLoadBalancerArray) ElementType 

func (NetworkLoadBalancerArray) ElementType() reflect.Type

func (NetworkLoadBalancerArray) ToNetworkLoadBalancerArrayOutput 

func (i NetworkLoadBalancerArray) ToNetworkLoadBalancerArrayOutput() NetworkLoadBalancerArrayOutput

func (NetworkLoadBalancerArray) ToNetworkLoadBalancerArrayOutputWithContext 

func (i NetworkLoadBalancerArray) ToNetworkLoadBalancerArrayOutputWithContext(ctx context.Context) NetworkLoadBalancerArrayOutput

type NetworkLoadBalancerArrayInput 

type NetworkLoadBalancerArrayInput interface {
	pulumi.Input

	ToNetworkLoadBalancerArrayOutput() NetworkLoadBalancerArrayOutput
	ToNetworkLoadBalancerArrayOutputWithContext(context.Context) NetworkLoadBalancerArrayOutput
}

NetworkLoadBalancerArrayInput is an input type that accepts NetworkLoadBalancerArray and NetworkLoadBalancerArrayOutput values. You can construct a concrete instance of `NetworkLoadBalancerArrayInput` via: 

NetworkLoadBalancerArray{ NetworkLoadBalancerArgs{...} }

type NetworkLoadBalancerArrayOutput 

type NetworkLoadBalancerArrayOutput struct{ *pulumi.OutputState }

func (NetworkLoadBalancerArrayOutput) ElementType 

func (NetworkLoadBalancerArrayOutput) ElementType() reflect.Type

func (NetworkLoadBalancerArrayOutput) Index 

func (o NetworkLoadBalancerArrayOutput) Index(i pulumi.IntInput) NetworkLoadBalancerOutput

func (NetworkLoadBalancerArrayOutput) ToNetworkLoadBalancerArrayOutput 

func (o NetworkLoadBalancerArrayOutput) ToNetworkLoadBalancerArrayOutput() NetworkLoadBalancerArrayOutput

func (NetworkLoadBalancerArrayOutput) ToNetworkLoadBalancerArrayOutputWithContext 

func (o NetworkLoadBalancerArrayOutput) ToNetworkLoadBalancerArrayOutputWithContext(ctx context.Context) NetworkLoadBalancerArrayOutput

type NetworkLoadBalancerInput 

type NetworkLoadBalancerInput interface {
	pulumi.Input

	ToNetworkLoadBalancerOutput() NetworkLoadBalancerOutput
	ToNetworkLoadBalancerOutputWithContext(ctx context.Context) NetworkLoadBalancerOutput
}

type NetworkLoadBalancerIpAddress 

type NetworkLoadBalancerIpAddress struct {
	// An IP address.  Example: `192.168.0.3`
	IpAddress *string `pulumi:"ipAddress"`
	// IP version associated with the listener.
	IpVersion *string `pulumi:"ipVersion"`
	// Whether the IP address is public or private.
	IsPublic *bool `pulumi:"isPublic"`
	// An object representing a reserved IP address to be attached or that is already attached to a network load balancer.
	ReservedIps []NetworkLoadBalancerIpAddressReservedIp `pulumi:"reservedIps"`
}

type NetworkLoadBalancerIpAddressArgs 

type NetworkLoadBalancerIpAddressArgs struct {
	// An IP address.  Example: `192.168.0.3`
	IpAddress pulumi.StringPtrInput `pulumi:"ipAddress"`
	// IP version associated with the listener.
	IpVersion pulumi.StringPtrInput `pulumi:"ipVersion"`
	// Whether the IP address is public or private.
	IsPublic pulumi.BoolPtrInput `pulumi:"isPublic"`
	// An object representing a reserved IP address to be attached or that is already attached to a network load balancer.
	ReservedIps NetworkLoadBalancerIpAddressReservedIpArrayInput `pulumi:"reservedIps"`
}

func (NetworkLoadBalancerIpAddressArgs) ElementType 

func (NetworkLoadBalancerIpAddressArgs) ElementType() reflect.Type

func (NetworkLoadBalancerIpAddressArgs) ToNetworkLoadBalancerIpAddressOutput 

func (i NetworkLoadBalancerIpAddressArgs) ToNetworkLoadBalancerIpAddressOutput() NetworkLoadBalancerIpAddressOutput

func (NetworkLoadBalancerIpAddressArgs) ToNetworkLoadBalancerIpAddressOutputWithContext 

func (i NetworkLoadBalancerIpAddressArgs) ToNetworkLoadBalancerIpAddressOutputWithContext(ctx context.Context) NetworkLoadBalancerIpAddressOutput

type NetworkLoadBalancerIpAddressArray 

type NetworkLoadBalancerIpAddressArray []NetworkLoadBalancerIpAddressInput

func (NetworkLoadBalancerIpAddressArray) ElementType 

func (NetworkLoadBalancerIpAddressArray) ElementType() reflect.Type

func (NetworkLoadBalancerIpAddressArray) ToNetworkLoadBalancerIpAddressArrayOutput 

func (i NetworkLoadBalancerIpAddressArray) ToNetworkLoadBalancerIpAddressArrayOutput() NetworkLoadBalancerIpAddressArrayOutput

func (NetworkLoadBalancerIpAddressArray) ToNetworkLoadBalancerIpAddressArrayOutputWithContext 

func (i NetworkLoadBalancerIpAddressArray) ToNetworkLoadBalancerIpAddressArrayOutputWithContext(ctx context.Context) NetworkLoadBalancerIpAddressArrayOutput

type NetworkLoadBalancerIpAddressArrayInput 

type NetworkLoadBalancerIpAddressArrayInput interface {
	pulumi.Input

	ToNetworkLoadBalancerIpAddressArrayOutput() NetworkLoadBalancerIpAddressArrayOutput
	ToNetworkLoadBalancerIpAddressArrayOutputWithContext(context.Context) NetworkLoadBalancerIpAddressArrayOutput
}

NetworkLoadBalancerIpAddressArrayInput is an input type that accepts NetworkLoadBalancerIpAddressArray and NetworkLoadBalancerIpAddressArrayOutput values. You can construct a concrete instance of `NetworkLoadBalancerIpAddressArrayInput` via: 

NetworkLoadBalancerIpAddressArray{ NetworkLoadBalancerIpAddressArgs{...} }

type NetworkLoadBalancerIpAddressArrayOutput 

type NetworkLoadBalancerIpAddressArrayOutput struct{ *pulumi.OutputState }

func (NetworkLoadBalancerIpAddressArrayOutput) ElementType 

func (NetworkLoadBalancerIpAddressArrayOutput) ElementType() reflect.Type

func (NetworkLoadBalancerIpAddressArrayOutput) Index 

func (o NetworkLoadBalancerIpAddressArrayOutput) Index(i pulumi.IntInput) NetworkLoadBalancerIpAddressOutput

func (NetworkLoadBalancerIpAddressArrayOutput) ToNetworkLoadBalancerIpAddressArrayOutput 

func (o NetworkLoadBalancerIpAddressArrayOutput) ToNetworkLoadBalancerIpAddressArrayOutput() NetworkLoadBalancerIpAddressArrayOutput

func (NetworkLoadBalancerIpAddressArrayOutput) ToNetworkLoadBalancerIpAddressArrayOutputWithContext 

func (o NetworkLoadBalancerIpAddressArrayOutput) ToNetworkLoadBalancerIpAddressArrayOutputWithContext(ctx context.Context) NetworkLoadBalancerIpAddressArrayOutput

type NetworkLoadBalancerIpAddressInput 

type NetworkLoadBalancerIpAddressInput interface {
	pulumi.Input

	ToNetworkLoadBalancerIpAddressOutput() NetworkLoadBalancerIpAddressOutput
	ToNetworkLoadBalancerIpAddressOutputWithContext(context.Context) NetworkLoadBalancerIpAddressOutput
}

NetworkLoadBalancerIpAddressInput is an input type that accepts NetworkLoadBalancerIpAddressArgs and NetworkLoadBalancerIpAddressOutput values. You can construct a concrete instance of `NetworkLoadBalancerIpAddressInput` via: 

NetworkLoadBalancerIpAddressArgs{...}

type NetworkLoadBalancerIpAddressOutput 

type NetworkLoadBalancerIpAddressOutput struct{ *pulumi.OutputState }

func (NetworkLoadBalancerIpAddressOutput) ElementType 

func (NetworkLoadBalancerIpAddressOutput) ElementType() reflect.Type

func (NetworkLoadBalancerIpAddressOutput) IpAddress 

func (o NetworkLoadBalancerIpAddressOutput) IpAddress() pulumi.StringPtrOutput

An IP address. Example: `192.168.0.3`

func (NetworkLoadBalancerIpAddressOutput) IpVersion 

func (o NetworkLoadBalancerIpAddressOutput) IpVersion() pulumi.StringPtrOutput

IP version associated with the listener.

func (NetworkLoadBalancerIpAddressOutput) IsPublic 

func (o NetworkLoadBalancerIpAddressOutput) IsPublic() pulumi.BoolPtrOutput

Whether the IP address is public or private.

func (NetworkLoadBalancerIpAddressOutput) ReservedIps 

func (o NetworkLoadBalancerIpAddressOutput) ReservedIps() NetworkLoadBalancerIpAddressReservedIpArrayOutput

An object representing a reserved IP address to be attached or that is already attached to a network load balancer.

func (NetworkLoadBalancerIpAddressOutput) ToNetworkLoadBalancerIpAddressOutput 

func (o NetworkLoadBalancerIpAddressOutput) ToNetworkLoadBalancerIpAddressOutput() NetworkLoadBalancerIpAddressOutput

func (NetworkLoadBalancerIpAddressOutput) ToNetworkLoadBalancerIpAddressOutputWithContext 

func (o NetworkLoadBalancerIpAddressOutput) ToNetworkLoadBalancerIpAddressOutputWithContext(ctx context.Context) NetworkLoadBalancerIpAddressOutput

type NetworkLoadBalancerIpAddressReservedIp 

type NetworkLoadBalancerIpAddressReservedIp struct {
	// OCID of the reserved public IP address created with the virtual cloud network.
	Id *string `pulumi:"id"`
}

type NetworkLoadBalancerIpAddressReservedIpArgs 

type NetworkLoadBalancerIpAddressReservedIpArgs struct {
	// OCID of the reserved public IP address created with the virtual cloud network.
	Id pulumi.StringPtrInput `pulumi:"id"`
}

func (NetworkLoadBalancerIpAddressReservedIpArgs) ElementType 

func (NetworkLoadBalancerIpAddressReservedIpArgs) ElementType() reflect.Type

func (NetworkLoadBalancerIpAddressReservedIpArgs) ToNetworkLoadBalancerIpAddressReservedIpOutput 

func (i NetworkLoadBalancerIpAddressReservedIpArgs) ToNetworkLoadBalancerIpAddressReservedIpOutput() NetworkLoadBalancerIpAddressReservedIpOutput

func (NetworkLoadBalancerIpAddressReservedIpArgs) ToNetworkLoadBalancerIpAddressReservedIpOutputWithContext 

func (i NetworkLoadBalancerIpAddressReservedIpArgs) ToNetworkLoadBalancerIpAddressReservedIpOutputWithContext(ctx context.Context) NetworkLoadBalancerIpAddressReservedIpOutput

type NetworkLoadBalancerIpAddressReservedIpArray 

type NetworkLoadBalancerIpAddressReservedIpArray []NetworkLoadBalancerIpAddressReservedIpInput

func (NetworkLoadBalancerIpAddressReservedIpArray) ElementType 

func (NetworkLoadBalancerIpAddressReservedIpArray) ElementType() reflect.Type

func (NetworkLoadBalancerIpAddressReservedIpArray) ToNetworkLoadBalancerIpAddressReservedIpArrayOutput 

func (i NetworkLoadBalancerIpAddressReservedIpArray) ToNetworkLoadBalancerIpAddressReservedIpArrayOutput() NetworkLoadBalancerIpAddressReservedIpArrayOutput

func (NetworkLoadBalancerIpAddressReservedIpArray) ToNetworkLoadBalancerIpAddressReservedIpArrayOutputWithContext 

func (i NetworkLoadBalancerIpAddressReservedIpArray) ToNetworkLoadBalancerIpAddressReservedIpArrayOutputWithContext(ctx context.Context) NetworkLoadBalancerIpAddressReservedIpArrayOutput

type NetworkLoadBalancerIpAddressReservedIpArrayInput 

type NetworkLoadBalancerIpAddressReservedIpArrayInput interface {
	pulumi.Input

	ToNetworkLoadBalancerIpAddressReservedIpArrayOutput() NetworkLoadBalancerIpAddressReservedIpArrayOutput
	ToNetworkLoadBalancerIpAddressReservedIpArrayOutputWithContext(context.Context) NetworkLoadBalancerIpAddressReservedIpArrayOutput
}

NetworkLoadBalancerIpAddressReservedIpArrayInput is an input type that accepts NetworkLoadBalancerIpAddressReservedIpArray and NetworkLoadBalancerIpAddressReservedIpArrayOutput values. You can construct a concrete instance of `NetworkLoadBalancerIpAddressReservedIpArrayInput` via: 

NetworkLoadBalancerIpAddressReservedIpArray{ NetworkLoadBalancerIpAddressReservedIpArgs{...} }

type NetworkLoadBalancerIpAddressReservedIpArrayOutput 

type NetworkLoadBalancerIpAddressReservedIpArrayOutput struct{ *pulumi.OutputState }

func (NetworkLoadBalancerIpAddressReservedIpArrayOutput) ElementType 

func (NetworkLoadBalancerIpAddressReservedIpArrayOutput) ElementType() reflect.Type

func (NetworkLoadBalancerIpAddressReservedIpArrayOutput) Index 

func (o NetworkLoadBalancerIpAddressReservedIpArrayOutput) Index(i pulumi.IntInput) NetworkLoadBalancerIpAddressReservedIpOutput

func (NetworkLoadBalancerIpAddressReservedIpArrayOutput) ToNetworkLoadBalancerIpAddressReservedIpArrayOutput 

func (o NetworkLoadBalancerIpAddressReservedIpArrayOutput) ToNetworkLoadBalancerIpAddressReservedIpArrayOutput() NetworkLoadBalancerIpAddressReservedIpArrayOutput

func (NetworkLoadBalancerIpAddressReservedIpArrayOutput) ToNetworkLoadBalancerIpAddressReservedIpArrayOutputWithContext 

func (o NetworkLoadBalancerIpAddressReservedIpArrayOutput) ToNetworkLoadBalancerIpAddressReservedIpArrayOutputWithContext(ctx context.Context) NetworkLoadBalancerIpAddressReservedIpArrayOutput

type NetworkLoadBalancerIpAddressReservedIpInput 

type NetworkLoadBalancerIpAddressReservedIpInput interface {
	pulumi.Input

	ToNetworkLoadBalancerIpAddressReservedIpOutput() NetworkLoadBalancerIpAddressReservedIpOutput
	ToNetworkLoadBalancerIpAddressReservedIpOutputWithContext(context.Context) NetworkLoadBalancerIpAddressReservedIpOutput
}

NetworkLoadBalancerIpAddressReservedIpInput is an input type that accepts NetworkLoadBalancerIpAddressReservedIpArgs and NetworkLoadBalancerIpAddressReservedIpOutput values. You can construct a concrete instance of `NetworkLoadBalancerIpAddressReservedIpInput` via: 

NetworkLoadBalancerIpAddressReservedIpArgs{...}

type NetworkLoadBalancerIpAddressReservedIpOutput 

type NetworkLoadBalancerIpAddressReservedIpOutput struct{ *pulumi.OutputState }

func (NetworkLoadBalancerIpAddressReservedIpOutput) ElementType 

func (NetworkLoadBalancerIpAddressReservedIpOutput) ElementType() reflect.Type

func (NetworkLoadBalancerIpAddressReservedIpOutput) Id 

func (o NetworkLoadBalancerIpAddressReservedIpOutput) Id() pulumi.StringPtrOutput

OCID of the reserved public IP address created with the virtual cloud network.

func (NetworkLoadBalancerIpAddressReservedIpOutput) ToNetworkLoadBalancerIpAddressReservedIpOutput 

func (o NetworkLoadBalancerIpAddressReservedIpOutput) ToNetworkLoadBalancerIpAddressReservedIpOutput() NetworkLoadBalancerIpAddressReservedIpOutput

func (NetworkLoadBalancerIpAddressReservedIpOutput) ToNetworkLoadBalancerIpAddressReservedIpOutputWithContext 

func (o NetworkLoadBalancerIpAddressReservedIpOutput) ToNetworkLoadBalancerIpAddressReservedIpOutputWithContext(ctx context.Context) NetworkLoadBalancerIpAddressReservedIpOutput

type NetworkLoadBalancerMap 

type NetworkLoadBalancerMap map[string]NetworkLoadBalancerInput

func (NetworkLoadBalancerMap) ElementType 

func (NetworkLoadBalancerMap) ElementType() reflect.Type

func (NetworkLoadBalancerMap) ToNetworkLoadBalancerMapOutput 

func (i NetworkLoadBalancerMap) ToNetworkLoadBalancerMapOutput() NetworkLoadBalancerMapOutput

func (NetworkLoadBalancerMap) ToNetworkLoadBalancerMapOutputWithContext 

func (i NetworkLoadBalancerMap) ToNetworkLoadBalancerMapOutputWithContext(ctx context.Context) NetworkLoadBalancerMapOutput

type NetworkLoadBalancerMapInput 

type NetworkLoadBalancerMapInput interface {
	pulumi.Input

	ToNetworkLoadBalancerMapOutput() NetworkLoadBalancerMapOutput
	ToNetworkLoadBalancerMapOutputWithContext(context.Context) NetworkLoadBalancerMapOutput
}

NetworkLoadBalancerMapInput is an input type that accepts NetworkLoadBalancerMap and NetworkLoadBalancerMapOutput values. You can construct a concrete instance of `NetworkLoadBalancerMapInput` via: 

NetworkLoadBalancerMap{ "key": NetworkLoadBalancerArgs{...} }

type NetworkLoadBalancerMapOutput 

type NetworkLoadBalancerMapOutput struct{ *pulumi.OutputState }

func (NetworkLoadBalancerMapOutput) ElementType 

func (NetworkLoadBalancerMapOutput) ElementType() reflect.Type

func (NetworkLoadBalancerMapOutput) MapIndex 

func (o NetworkLoadBalancerMapOutput) MapIndex(k pulumi.StringInput) NetworkLoadBalancerOutput

func (NetworkLoadBalancerMapOutput) ToNetworkLoadBalancerMapOutput 

func (o NetworkLoadBalancerMapOutput) ToNetworkLoadBalancerMapOutput() NetworkLoadBalancerMapOutput

func (NetworkLoadBalancerMapOutput) ToNetworkLoadBalancerMapOutputWithContext 

func (o NetworkLoadBalancerMapOutput) ToNetworkLoadBalancerMapOutputWithContext(ctx context.Context) NetworkLoadBalancerMapOutput

type NetworkLoadBalancerOutput 

type NetworkLoadBalancerOutput struct{ *pulumi.OutputState }

func (NetworkLoadBalancerOutput) AssignedIpv6 

func (o NetworkLoadBalancerOutput) AssignedIpv6() pulumi.StringPtrOutput

IPv6 address to be assigned to the network load balancer being created. This IP address has to be part of one of the prefixes supported by the subnet. Example: "2607:9b80:9a0a:9a7e:abcd:ef01:2345:6789"

func (NetworkLoadBalancerOutput) AssignedPrivateIpv4 

func (o NetworkLoadBalancerOutput) AssignedPrivateIpv4() pulumi.StringPtrOutput

Private IP address to be assigned to the network load balancer being created. This IP address has to be in the CIDR range of the subnet where network load balancer is being created Example: "10.0.0.1"

func (NetworkLoadBalancerOutput) CompartmentId 

func (o NetworkLoadBalancerOutput) CompartmentId() pulumi.StringOutput

(Updatable) The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the compartment containing the network load balancer.

func (NetworkLoadBalancerOutput) DefinedTags 

func (o NetworkLoadBalancerOutput) DefinedTags() pulumi.StringMapOutput

(Updatable) Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`

func (NetworkLoadBalancerOutput) DisplayName 

func (o NetworkLoadBalancerOutput) DisplayName() pulumi.StringOutput

(Updatable) Network load balancer identifier, which can be renamed.

func (NetworkLoadBalancerOutput) ElementType 

func (NetworkLoadBalancerOutput) ElementType() reflect.Type

func (NetworkLoadBalancerOutput) FreeformTags 

func (o NetworkLoadBalancerOutput) FreeformTags() pulumi.StringMapOutput

(Updatable) Simple key-value pair that is applied without any predefined name, type, or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`

func (NetworkLoadBalancerOutput) IpAddresses 

func (o NetworkLoadBalancerOutput) IpAddresses() NetworkLoadBalancerIpAddressArrayOutput

An array of IP addresses.

func (NetworkLoadBalancerOutput) IsPreserveSourceDestination 

func (o NetworkLoadBalancerOutput) IsPreserveSourceDestination() pulumi.BoolOutput

(Updatable) This parameter can be enabled only if backends are compute OCIDs. When enabled, the skipSourceDestinationCheck parameter is automatically enabled on the load balancer VNIC, and packets are sent to the backend with the entire IP header intact.

func (NetworkLoadBalancerOutput) IsPrivate 

func (o NetworkLoadBalancerOutput) IsPrivate() pulumi.BoolOutput

Whether the network load balancer has a virtual cloud network-local (private) IP address.

If "true", then the service assigns a private IP address to the network load balancer.

If "false", then the service assigns a public IP address to the network load balancer.

A public network load balancer is accessible from the internet, depending on the [security list rules](https://docs.cloud.oracle.com/iaas/Content/network/Concepts/securitylists.htm) for your virtual cloud network. For more information about public and private network load balancers, see [How Network Load Balancing Works](https://docs.cloud.oracle.com/iaas/Content/Balance/Concepts/balanceoverview.htm#how-network-load-balancing-works). This value is true by default.

Example: `true`

func (NetworkLoadBalancerOutput) IsSymmetricHashEnabled 

func (o NetworkLoadBalancerOutput) IsSymmetricHashEnabled() pulumi.BoolOutput

(Updatable) This can only be enabled when NLB is working in transparent mode with source destination header preservation enabled. This removes the additional dependency from NLB backends(like Firewalls) to perform SNAT.

Example: `true` Example: `true`

func (NetworkLoadBalancerOutput) LifecycleDetails 

func (o NetworkLoadBalancerOutput) LifecycleDetails() pulumi.StringOutput

A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.

func (NetworkLoadBalancerOutput) NetworkSecurityGroupIds 

func (o NetworkLoadBalancerOutput) NetworkSecurityGroupIds() pulumi.StringArrayOutput

(Updatable) An array of network security groups [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) associated with the network load balancer.

During the creation of the network load balancer, the service adds the new load balancer to the specified network security groups.

The benefits of associating the network load balancer with network security groups include: * Network security groups define network security rules to govern ingress and egress traffic for the network load balancer. * The network security rules of other resources can reference the network security groups associated with the network load balancer to ensure access.

Example: ["ocid1.nsg.oc1.phx.unique_ID"]

func (NetworkLoadBalancerOutput) NlbIpVersion 

func (o NetworkLoadBalancerOutput) NlbIpVersion() pulumi.StringOutput

(Updatable) IP version associated with the NLB.

func (NetworkLoadBalancerOutput) ReservedIps 

func (o NetworkLoadBalancerOutput) ReservedIps() NetworkLoadBalancerReservedIpArrayOutput

An array of reserved Ips.

func (NetworkLoadBalancerOutput) State 

func (o NetworkLoadBalancerOutput) State() pulumi.StringOutput

The current state of the network load balancer.

func (NetworkLoadBalancerOutput) SubnetId 

func (o NetworkLoadBalancerOutput) SubnetId() pulumi.StringOutput

The subnet in which the network load balancer is spawned [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).

func (NetworkLoadBalancerOutput) SubnetIpv6cidr 

func (o NetworkLoadBalancerOutput) SubnetIpv6cidr() pulumi.StringPtrOutput

IPv6 subnet prefix selection. If Ipv6 subnet prefix is passed, Nlb Ipv6 Address would be assign within the cidr block. NLB has to be dual or single stack ipv6 to support this.

** IMPORTANT ** Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values

func (NetworkLoadBalancerOutput) SystemTags 

func (o NetworkLoadBalancerOutput) SystemTags() pulumi.StringMapOutput

Key-value pair representing system tags' keys and values scoped to a namespace. Example: `{"bar-key": "value"}`

func (NetworkLoadBalancerOutput) TimeCreated 

func (o NetworkLoadBalancerOutput) TimeCreated() pulumi.StringOutput

The date and time the network load balancer was created, in the format defined by RFC3339. Example: `2020-05-01T21:10:29.600Z`

func (NetworkLoadBalancerOutput) TimeUpdated 

func (o NetworkLoadBalancerOutput) TimeUpdated() pulumi.StringOutput

The time the network load balancer was updated. An RFC3339 formatted date-time string. Example: `2020-05-01T22:10:29.600Z`

func (NetworkLoadBalancerOutput) ToNetworkLoadBalancerOutput 

func (o NetworkLoadBalancerOutput) ToNetworkLoadBalancerOutput() NetworkLoadBalancerOutput

func (NetworkLoadBalancerOutput) ToNetworkLoadBalancerOutputWithContext 

func (o NetworkLoadBalancerOutput) ToNetworkLoadBalancerOutputWithContext(ctx context.Context) NetworkLoadBalancerOutput

type NetworkLoadBalancerReservedIp 

type NetworkLoadBalancerReservedIp struct {
	// OCID of the reserved public IP address created with the virtual cloud network.
	//
	// Reserved public IP addresses are IP addresses that are registered using the virtual cloud network API.
	//
	// Create a reserved public IP address. When you create the network load balancer, enter the OCID of the reserved public IP address in the reservedIp field to attach the IP address to the network load balancer. This task configures the network load balancer to listen to traffic on this IP address.
	//
	// Reserved public IP addresses are not deleted when the network load balancer is deleted. The IP addresses become unattached from the network load balancer.
	//
	// Example: "ocid1.publicip.oc1.phx.unique_ID"
	Id *string `pulumi:"id"`
}

type NetworkLoadBalancerReservedIpArgs 

type NetworkLoadBalancerReservedIpArgs struct {
	// OCID of the reserved public IP address created with the virtual cloud network.
	//
	// Reserved public IP addresses are IP addresses that are registered using the virtual cloud network API.
	//
	// Create a reserved public IP address. When you create the network load balancer, enter the OCID of the reserved public IP address in the reservedIp field to attach the IP address to the network load balancer. This task configures the network load balancer to listen to traffic on this IP address.
	//
	// Reserved public IP addresses are not deleted when the network load balancer is deleted. The IP addresses become unattached from the network load balancer.
	//
	// Example: "ocid1.publicip.oc1.phx.unique_ID"
	Id pulumi.StringPtrInput `pulumi:"id"`
}

func (NetworkLoadBalancerReservedIpArgs) ElementType 

func (NetworkLoadBalancerReservedIpArgs) ElementType() reflect.Type

func (NetworkLoadBalancerReservedIpArgs) ToNetworkLoadBalancerReservedIpOutput 

func (i NetworkLoadBalancerReservedIpArgs) ToNetworkLoadBalancerReservedIpOutput() NetworkLoadBalancerReservedIpOutput

func (NetworkLoadBalancerReservedIpArgs) ToNetworkLoadBalancerReservedIpOutputWithContext 

func (i NetworkLoadBalancerReservedIpArgs) ToNetworkLoadBalancerReservedIpOutputWithContext(ctx context.Context) NetworkLoadBalancerReservedIpOutput

type NetworkLoadBalancerReservedIpArray 

type NetworkLoadBalancerReservedIpArray []NetworkLoadBalancerReservedIpInput

func (NetworkLoadBalancerReservedIpArray) ElementType 

func (NetworkLoadBalancerReservedIpArray) ElementType() reflect.Type

func (NetworkLoadBalancerReservedIpArray) ToNetworkLoadBalancerReservedIpArrayOutput 

func (i NetworkLoadBalancerReservedIpArray) ToNetworkLoadBalancerReservedIpArrayOutput() NetworkLoadBalancerReservedIpArrayOutput

func (NetworkLoadBalancerReservedIpArray) ToNetworkLoadBalancerReservedIpArrayOutputWithContext 

func (i NetworkLoadBalancerReservedIpArray) ToNetworkLoadBalancerReservedIpArrayOutputWithContext(ctx context.Context) NetworkLoadBalancerReservedIpArrayOutput

type NetworkLoadBalancerReservedIpArrayInput 

type NetworkLoadBalancerReservedIpArrayInput interface {
	pulumi.Input

	ToNetworkLoadBalancerReservedIpArrayOutput() NetworkLoadBalancerReservedIpArrayOutput
	ToNetworkLoadBalancerReservedIpArrayOutputWithContext(context.Context) NetworkLoadBalancerReservedIpArrayOutput
}

NetworkLoadBalancerReservedIpArrayInput is an input type that accepts NetworkLoadBalancerReservedIpArray and NetworkLoadBalancerReservedIpArrayOutput values. You can construct a concrete instance of `NetworkLoadBalancerReservedIpArrayInput` via: 

NetworkLoadBalancerReservedIpArray{ NetworkLoadBalancerReservedIpArgs{...} }

type NetworkLoadBalancerReservedIpArrayOutput 

type NetworkLoadBalancerReservedIpArrayOutput struct{ *pulumi.OutputState }

func (NetworkLoadBalancerReservedIpArrayOutput) ElementType 

func (NetworkLoadBalancerReservedIpArrayOutput) ElementType() reflect.Type

func (NetworkLoadBalancerReservedIpArrayOutput) Index 

func (o NetworkLoadBalancerReservedIpArrayOutput) Index(i pulumi.IntInput) NetworkLoadBalancerReservedIpOutput

func (NetworkLoadBalancerReservedIpArrayOutput) ToNetworkLoadBalancerReservedIpArrayOutput 

func (o NetworkLoadBalancerReservedIpArrayOutput) ToNetworkLoadBalancerReservedIpArrayOutput() NetworkLoadBalancerReservedIpArrayOutput

func (NetworkLoadBalancerReservedIpArrayOutput) ToNetworkLoadBalancerReservedIpArrayOutputWithContext 

func (o NetworkLoadBalancerReservedIpArrayOutput) ToNetworkLoadBalancerReservedIpArrayOutputWithContext(ctx context.Context) NetworkLoadBalancerReservedIpArrayOutput

type NetworkLoadBalancerReservedIpInput 

type NetworkLoadBalancerReservedIpInput interface {
	pulumi.Input

	ToNetworkLoadBalancerReservedIpOutput() NetworkLoadBalancerReservedIpOutput
	ToNetworkLoadBalancerReservedIpOutputWithContext(context.Context) NetworkLoadBalancerReservedIpOutput
}

NetworkLoadBalancerReservedIpInput is an input type that accepts NetworkLoadBalancerReservedIpArgs and NetworkLoadBalancerReservedIpOutput values. You can construct a concrete instance of `NetworkLoadBalancerReservedIpInput` via: 

NetworkLoadBalancerReservedIpArgs{...}

type NetworkLoadBalancerReservedIpOutput 

type NetworkLoadBalancerReservedIpOutput struct{ *pulumi.OutputState }

func (NetworkLoadBalancerReservedIpOutput) ElementType 

func (NetworkLoadBalancerReservedIpOutput) ElementType() reflect.Type

func (NetworkLoadBalancerReservedIpOutput) Id 

func (o NetworkLoadBalancerReservedIpOutput) Id() pulumi.StringPtrOutput

OCID of the reserved public IP address created with the virtual cloud network.

Reserved public IP addresses are IP addresses that are registered using the virtual cloud network API.

Create a reserved public IP address. When you create the network load balancer, enter the OCID of the reserved public IP address in the reservedIp field to attach the IP address to the network load balancer. This task configures the network load balancer to listen to traffic on this IP address.

Reserved public IP addresses are not deleted when the network load balancer is deleted. The IP addresses become unattached from the network load balancer.

Example: "ocid1.publicip.oc1.phx.unique_ID"

func (NetworkLoadBalancerReservedIpOutput) ToNetworkLoadBalancerReservedIpOutput 

func (o NetworkLoadBalancerReservedIpOutput) ToNetworkLoadBalancerReservedIpOutput() NetworkLoadBalancerReservedIpOutput

func (NetworkLoadBalancerReservedIpOutput) ToNetworkLoadBalancerReservedIpOutputWithContext 

func (o NetworkLoadBalancerReservedIpOutput) ToNetworkLoadBalancerReservedIpOutputWithContext(ctx context.Context) NetworkLoadBalancerReservedIpOutput

type NetworkLoadBalancerState 

type NetworkLoadBalancerState struct {
	// IPv6 address to be assigned to the network load balancer being created. This IP address has to be part of one of the prefixes supported by the subnet. Example: "2607:9b80:9a0a:9a7e:abcd:ef01:2345:6789"
	AssignedIpv6 pulumi.StringPtrInput
	// Private IP address to be assigned to the network load balancer being created. This IP address has to be in the CIDR range of the subnet where network load balancer is being created Example: "10.0.0.1"
	AssignedPrivateIpv4 pulumi.StringPtrInput
	// (Updatable) The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the compartment containing the network load balancer.
	CompartmentId pulumi.StringPtrInput
	// (Updatable) Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
	DefinedTags pulumi.StringMapInput
	// (Updatable) Network load balancer identifier, which can be renamed.
	DisplayName pulumi.StringPtrInput
	// (Updatable) Simple key-value pair that is applied without any predefined name, type, or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
	FreeformTags pulumi.StringMapInput
	// An array of IP addresses.
	IpAddresses NetworkLoadBalancerIpAddressArrayInput
	// (Updatable) This parameter can be enabled only if backends are compute OCIDs. When enabled, the skipSourceDestinationCheck parameter is automatically enabled on the load balancer VNIC, and packets are sent to the backend with the entire IP header intact.
	IsPreserveSourceDestination pulumi.BoolPtrInput
	// Whether the network load balancer has a virtual cloud network-local (private) IP address.
	//
	// If "true", then the service assigns a private IP address to the network load balancer.
	//
	// If "false", then the service assigns a public IP address to the network load balancer.
	//
	// A public network load balancer is accessible from the internet, depending on the [security list rules](https://docs.cloud.oracle.com/iaas/Content/network/Concepts/securitylists.htm) for your virtual cloud network. For more information about public and private network load balancers, see [How Network Load Balancing Works](https://docs.cloud.oracle.com/iaas/Content/Balance/Concepts/balanceoverview.htm#how-network-load-balancing-works). This value is true by default.
	//
	// Example: `true`
	IsPrivate pulumi.BoolPtrInput
	// (Updatable) This can only be enabled when NLB is working in transparent mode with source destination header preservation enabled.  This removes the additional dependency from NLB backends(like Firewalls) to perform SNAT.
	//
	// Example: `true`
	// Example: `true`
	IsSymmetricHashEnabled pulumi.BoolPtrInput
	// A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
	LifecycleDetails pulumi.StringPtrInput
	// (Updatable) An array of network security groups [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) associated with the network load balancer.
	//
	// During the creation of the network load balancer, the service adds the new load balancer to the specified network security groups.
	//
	// The benefits of associating the network load balancer with network security groups include:
	// *  Network security groups define network security rules to govern ingress and egress traffic for the network load balancer.
	// *  The network security rules of other resources can reference the network security groups associated with the network load balancer to ensure access.
	//
	// Example: ["ocid1.nsg.oc1.phx.unique_ID"]
	NetworkSecurityGroupIds pulumi.StringArrayInput
	// (Updatable) IP version associated with the NLB.
	NlbIpVersion pulumi.StringPtrInput
	// An array of reserved Ips.
	ReservedIps NetworkLoadBalancerReservedIpArrayInput
	// The current state of the network load balancer.
	State pulumi.StringPtrInput
	// The subnet in which the network load balancer is spawned [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
	SubnetId pulumi.StringPtrInput
	// IPv6 subnet prefix selection. If Ipv6 subnet prefix is passed, Nlb Ipv6 Address would be assign within the cidr block. NLB has to be dual or single stack ipv6 to support this.
	//
	// ** IMPORTANT **
	// Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
	SubnetIpv6cidr pulumi.StringPtrInput
	// Key-value pair representing system tags' keys and values scoped to a namespace. Example: `{"bar-key": "value"}`
	SystemTags pulumi.StringMapInput
	// The date and time the network load balancer was created, in the format defined by RFC3339.  Example: `2020-05-01T21:10:29.600Z`
	TimeCreated pulumi.StringPtrInput
	// The time the network load balancer was updated. An RFC3339 formatted date-time string.  Example: `2020-05-01T22:10:29.600Z`
	TimeUpdated pulumi.StringPtrInput
}

func (NetworkLoadBalancerState) ElementType 

func (NetworkLoadBalancerState) ElementType() reflect.Type

type NetworkLoadBalancersBackendSetsUnified 

type NetworkLoadBalancersBackendSetsUnified struct {
	pulumi.CustomResourceState

	// (Updatable) An array of backends to be associated with the backend set.
	Backends NetworkLoadBalancersBackendSetsUnifiedBackendArrayOutput `pulumi:"backends"`
	// (Updatable) The health check policy configuration. For more information, see [Editing Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/Balance/Tasks/editinghealthcheck.htm).
	HealthChecker NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput `pulumi:"healthChecker"`
	// (Updatable) IP version associated with the backend set.
	IpVersion pulumi.StringOutput `pulumi:"ipVersion"`
	// (Updatable) If enabled, the network load balancer will continue to distribute traffic in the configured distribution in the event all backends are unhealthy. The value is false by default.
	IsFailOpen pulumi.BoolOutput `pulumi:"isFailOpen"`
	// (Updatable) If enabled existing connections will be forwarded to an alternative healthy backend as soon as current backend becomes unhealthy.
	IsInstantFailoverEnabled pulumi.BoolOutput `pulumi:"isInstantFailoverEnabled"`
	// (Updatable) If this parameter is enabled, then the network load balancer preserves the source IP of the packet when it is forwarded to backends. Backends see the original source IP. If the isPreserveSourceDestination parameter is enabled for the network load balancer resource, then this parameter cannot be disabled. The value is true by default.
	IsPreserveSource pulumi.BoolOutput `pulumi:"isPreserveSource"`
	// A user-friendly name for the backend set that must be unique and cannot be changed.
	//
	// Valid backend set names include only alphanumeric characters, dashes, and underscores. Backend set names cannot contain spaces. Avoid entering confidential information.
	//
	// Example: `exampleBackendSet`
	Name pulumi.StringOutput `pulumi:"name"`
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId pulumi.StringOutput `pulumi:"networkLoadBalancerId"`
	// (Updatable) The network load balancer policy for the backend set.  Example: `FIVE_TUPLE“
	//
	// ** IMPORTANT **
	// Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
	Policy pulumi.StringOutput `pulumi:"policy"`
}

This resource provides the Network Load Balancers Backend Sets Unified resource in Oracle Cloud Infrastructure Network Load Balancer service.

Adds a backend set to a network load balancer.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-oci/sdk/v2/go/oci/NetworkLoadBalancer"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := NetworkLoadBalancer.NewNetworkLoadBalancersBackendSetsUnified(ctx, "test_network_load_balancers_backend_sets_unified", &NetworkLoadBalancer.NetworkLoadBalancersBackendSetsUnifiedArgs{
			HealthChecker: &networkloadbalancer.NetworkLoadBalancersBackendSetsUnifiedHealthCheckerArgs{
				Protocol: pulumi.Any(networkLoadBalancersBackendSetsUnifiedHealthCheckerProtocol),
				Dns: &networkloadbalancer.NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsArgs{
					DomainName:        pulumi.Any(testDomain.Name),
					QueryClass:        pulumi.Any(networkLoadBalancersBackendSetsUnifiedHealthCheckerDnsQueryClass),
					QueryType:         pulumi.Any(networkLoadBalancersBackendSetsUnifiedHealthCheckerDnsQueryType),
					Rcodes:            pulumi.Any(networkLoadBalancersBackendSetsUnifiedHealthCheckerDnsRcodes),
					TransportProtocol: pulumi.Any(networkLoadBalancersBackendSetsUnifiedHealthCheckerDnsTransportProtocol),
				},
				IntervalInMillis:  pulumi.Any(networkLoadBalancersBackendSetsUnifiedHealthCheckerIntervalInMillis),
				Port:              pulumi.Any(networkLoadBalancersBackendSetsUnifiedHealthCheckerPort),
				RequestData:       pulumi.Any(networkLoadBalancersBackendSetsUnifiedHealthCheckerRequestData),
				ResponseBodyRegex: pulumi.Any(networkLoadBalancersBackendSetsUnifiedHealthCheckerResponseBodyRegex),
				ResponseData:      pulumi.Any(networkLoadBalancersBackendSetsUnifiedHealthCheckerResponseData),
				Retries:           pulumi.Any(networkLoadBalancersBackendSetsUnifiedHealthCheckerRetries),
				ReturnCode:        pulumi.Any(networkLoadBalancersBackendSetsUnifiedHealthCheckerReturnCode),
				TimeoutInMillis:   pulumi.Any(networkLoadBalancersBackendSetsUnifiedHealthCheckerTimeoutInMillis),
				UrlPath:           pulumi.Any(networkLoadBalancersBackendSetsUnifiedHealthCheckerUrlPath),
			},
			Name:                  pulumi.Any(networkLoadBalancersBackendSetsUnifiedName),
			NetworkLoadBalancerId: pulumi.Any(testNetworkLoadBalancer.Id),
			Policy:                pulumi.Any(networkLoadBalancersBackendSetsUnifiedPolicy),
			Backends: networkloadbalancer.NetworkLoadBalancersBackendSetsUnifiedBackendArray{
				&networkloadbalancer.NetworkLoadBalancersBackendSetsUnifiedBackendArgs{
					Port:      pulumi.Any(networkLoadBalancersBackendSetsUnifiedBackendsPort),
					IpAddress: pulumi.Any(networkLoadBalancersBackendSetsUnifiedBackendsIpAddress),
					IsBackup:  pulumi.Any(networkLoadBalancersBackendSetsUnifiedBackendsIsBackup),
					IsDrain:   pulumi.Any(networkLoadBalancersBackendSetsUnifiedBackendsIsDrain),
					IsOffline: pulumi.Any(networkLoadBalancersBackendSetsUnifiedBackendsIsOffline),
					Name:      pulumi.Any(networkLoadBalancersBackendSetsUnifiedBackendsName),
					TargetId:  pulumi.Any(testTarget.Id),
					Weight:    pulumi.Any(networkLoadBalancersBackendSetsUnifiedBackendsWeight),
				},
			},
			IpVersion:                pulumi.Any(networkLoadBalancersBackendSetsUnifiedIpVersion),
			IsFailOpen:               pulumi.Any(networkLoadBalancersBackendSetsUnifiedIsFailOpen),
			IsInstantFailoverEnabled: pulumi.Any(networkLoadBalancersBackendSetsUnifiedIsInstantFailoverEnabled),
			IsPreserveSource:         pulumi.Any(networkLoadBalancersBackendSetsUnifiedIsPreserveSource),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

NetworkLoadBalancersBackendSetsUnified can be imported using the `id`, e.g.

```sh $ pulumi import oci:NetworkLoadBalancer/networkLoadBalancersBackendSetsUnified:NetworkLoadBalancersBackendSetsUnified test_network_load_balancers_backend_sets_unified "networkLoadBalancers/{networkLoadBalancerId}/backendSets/{backendSetName}" ```

func GetNetworkLoadBalancersBackendSetsUnified 

func GetNetworkLoadBalancersBackendSetsUnified(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *NetworkLoadBalancersBackendSetsUnifiedState, opts ...pulumi.ResourceOption) (*NetworkLoadBalancersBackendSetsUnified, error)

GetNetworkLoadBalancersBackendSetsUnified gets an existing NetworkLoadBalancersBackendSetsUnified 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 NewNetworkLoadBalancersBackendSetsUnified 

func NewNetworkLoadBalancersBackendSetsUnified(ctx *pulumi.Context,
	name string, args *NetworkLoadBalancersBackendSetsUnifiedArgs, opts ...pulumi.ResourceOption) (*NetworkLoadBalancersBackendSetsUnified, error)

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

func (*NetworkLoadBalancersBackendSetsUnified) ElementType 

func (*NetworkLoadBalancersBackendSetsUnified) ElementType() reflect.Type

func (*NetworkLoadBalancersBackendSetsUnified) ToNetworkLoadBalancersBackendSetsUnifiedOutput 

func (i *NetworkLoadBalancersBackendSetsUnified) ToNetworkLoadBalancersBackendSetsUnifiedOutput() NetworkLoadBalancersBackendSetsUnifiedOutput

func (*NetworkLoadBalancersBackendSetsUnified) ToNetworkLoadBalancersBackendSetsUnifiedOutputWithContext 

func (i *NetworkLoadBalancersBackendSetsUnified) ToNetworkLoadBalancersBackendSetsUnifiedOutputWithContext(ctx context.Context) NetworkLoadBalancersBackendSetsUnifiedOutput

type NetworkLoadBalancersBackendSetsUnifiedArgs 

type NetworkLoadBalancersBackendSetsUnifiedArgs struct {
	// (Updatable) An array of backends to be associated with the backend set.
	Backends NetworkLoadBalancersBackendSetsUnifiedBackendArrayInput
	// (Updatable) The health check policy configuration. For more information, see [Editing Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/Balance/Tasks/editinghealthcheck.htm).
	HealthChecker NetworkLoadBalancersBackendSetsUnifiedHealthCheckerInput
	// (Updatable) IP version associated with the backend set.
	IpVersion pulumi.StringPtrInput
	// (Updatable) If enabled, the network load balancer will continue to distribute traffic in the configured distribution in the event all backends are unhealthy. The value is false by default.
	IsFailOpen pulumi.BoolPtrInput
	// (Updatable) If enabled existing connections will be forwarded to an alternative healthy backend as soon as current backend becomes unhealthy.
	IsInstantFailoverEnabled pulumi.BoolPtrInput
	// (Updatable) If this parameter is enabled, then the network load balancer preserves the source IP of the packet when it is forwarded to backends. Backends see the original source IP. If the isPreserveSourceDestination parameter is enabled for the network load balancer resource, then this parameter cannot be disabled. The value is true by default.
	IsPreserveSource pulumi.BoolPtrInput
	// A user-friendly name for the backend set that must be unique and cannot be changed.
	//
	// Valid backend set names include only alphanumeric characters, dashes, and underscores. Backend set names cannot contain spaces. Avoid entering confidential information.
	//
	// Example: `exampleBackendSet`
	Name pulumi.StringPtrInput
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId pulumi.StringInput
	// (Updatable) The network load balancer policy for the backend set.  Example: `FIVE_TUPLE“
	//
	// ** IMPORTANT **
	// Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
	Policy pulumi.StringInput
}

The set of arguments for constructing a NetworkLoadBalancersBackendSetsUnified resource.

func (NetworkLoadBalancersBackendSetsUnifiedArgs) ElementType 

func (NetworkLoadBalancersBackendSetsUnifiedArgs) ElementType() reflect.Type

type NetworkLoadBalancersBackendSetsUnifiedArray 

type NetworkLoadBalancersBackendSetsUnifiedArray []NetworkLoadBalancersBackendSetsUnifiedInput

func (NetworkLoadBalancersBackendSetsUnifiedArray) ElementType 

func (NetworkLoadBalancersBackendSetsUnifiedArray) ElementType() reflect.Type

func (NetworkLoadBalancersBackendSetsUnifiedArray) ToNetworkLoadBalancersBackendSetsUnifiedArrayOutput 

func (i NetworkLoadBalancersBackendSetsUnifiedArray) ToNetworkLoadBalancersBackendSetsUnifiedArrayOutput() NetworkLoadBalancersBackendSetsUnifiedArrayOutput

func (NetworkLoadBalancersBackendSetsUnifiedArray) ToNetworkLoadBalancersBackendSetsUnifiedArrayOutputWithContext 

func (i NetworkLoadBalancersBackendSetsUnifiedArray) ToNetworkLoadBalancersBackendSetsUnifiedArrayOutputWithContext(ctx context.Context) NetworkLoadBalancersBackendSetsUnifiedArrayOutput

type NetworkLoadBalancersBackendSetsUnifiedArrayInput 

type NetworkLoadBalancersBackendSetsUnifiedArrayInput interface {
	pulumi.Input

	ToNetworkLoadBalancersBackendSetsUnifiedArrayOutput() NetworkLoadBalancersBackendSetsUnifiedArrayOutput
	ToNetworkLoadBalancersBackendSetsUnifiedArrayOutputWithContext(context.Context) NetworkLoadBalancersBackendSetsUnifiedArrayOutput
}

NetworkLoadBalancersBackendSetsUnifiedArrayInput is an input type that accepts NetworkLoadBalancersBackendSetsUnifiedArray and NetworkLoadBalancersBackendSetsUnifiedArrayOutput values. You can construct a concrete instance of `NetworkLoadBalancersBackendSetsUnifiedArrayInput` via: 

NetworkLoadBalancersBackendSetsUnifiedArray{ NetworkLoadBalancersBackendSetsUnifiedArgs{...} }

type NetworkLoadBalancersBackendSetsUnifiedArrayOutput 

type NetworkLoadBalancersBackendSetsUnifiedArrayOutput struct{ *pulumi.OutputState }

func (NetworkLoadBalancersBackendSetsUnifiedArrayOutput) ElementType 

func (NetworkLoadBalancersBackendSetsUnifiedArrayOutput) ElementType() reflect.Type

func (NetworkLoadBalancersBackendSetsUnifiedArrayOutput) Index 

func (o NetworkLoadBalancersBackendSetsUnifiedArrayOutput) Index(i pulumi.IntInput) NetworkLoadBalancersBackendSetsUnifiedOutput

func (NetworkLoadBalancersBackendSetsUnifiedArrayOutput) ToNetworkLoadBalancersBackendSetsUnifiedArrayOutput 

func (o NetworkLoadBalancersBackendSetsUnifiedArrayOutput) ToNetworkLoadBalancersBackendSetsUnifiedArrayOutput() NetworkLoadBalancersBackendSetsUnifiedArrayOutput

func (NetworkLoadBalancersBackendSetsUnifiedArrayOutput) ToNetworkLoadBalancersBackendSetsUnifiedArrayOutputWithContext 

func (o NetworkLoadBalancersBackendSetsUnifiedArrayOutput) ToNetworkLoadBalancersBackendSetsUnifiedArrayOutputWithContext(ctx context.Context) NetworkLoadBalancersBackendSetsUnifiedArrayOutput

type NetworkLoadBalancersBackendSetsUnifiedBackend 

type NetworkLoadBalancersBackendSetsUnifiedBackend struct {
	// (Updatable) The IP address of the backend server.  Example: `10.0.0.3`
	IpAddress *string `pulumi:"ipAddress"`
	// (Updatable) Whether the network load balancer should treat this server as a backup unit. If `true`, then the network load balancer forwards no ingress traffic to this backend server unless all other backend servers not marked as "isBackup" fail the health check policy.  Example: `false`
	IsBackup *bool `pulumi:"isBackup"`
	// (Updatable) Whether the network load balancer should drain this server. Servers marked "isDrain" receive no incoming traffic.  Example: `false`
	IsDrain *bool `pulumi:"isDrain"`
	// (Updatable) Whether the network load balancer should treat this server as offline. Offline servers receive no incoming traffic.  Example: `false`
	IsOffline *bool `pulumi:"isOffline"`
	// (Updatable) A read-only field showing the IP address/OCID and port that uniquely identify this backend server in the backend set.  Example: `10.0.0.3:8080`, or `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>:443` or `10.0.0.3:0`
	Name *string `pulumi:"name"`
	// (Updatable) The communication port for the backend server.  Example: `8080`
	Port int `pulumi:"port"`
	// (Updatable) The IP OCID/Instance OCID associated with the backend server. Example: `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>`
	TargetId *string `pulumi:"targetId"`
	// (Updatable) The network load balancing policy weight assigned to the server. Backend servers with a higher weight receive a larger proportion of incoming traffic. For example, a server weighted '3' receives three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/lbpolicies.htm).  Example: `3`
	Weight *int `pulumi:"weight"`
}

type NetworkLoadBalancersBackendSetsUnifiedBackendArgs 

type NetworkLoadBalancersBackendSetsUnifiedBackendArgs struct {
	// (Updatable) The IP address of the backend server.  Example: `10.0.0.3`
	IpAddress pulumi.StringPtrInput `pulumi:"ipAddress"`
	// (Updatable) Whether the network load balancer should treat this server as a backup unit. If `true`, then the network load balancer forwards no ingress traffic to this backend server unless all other backend servers not marked as "isBackup" fail the health check policy.  Example: `false`
	IsBackup pulumi.BoolPtrInput `pulumi:"isBackup"`
	// (Updatable) Whether the network load balancer should drain this server. Servers marked "isDrain" receive no incoming traffic.  Example: `false`
	IsDrain pulumi.BoolPtrInput `pulumi:"isDrain"`
	// (Updatable) Whether the network load balancer should treat this server as offline. Offline servers receive no incoming traffic.  Example: `false`
	IsOffline pulumi.BoolPtrInput `pulumi:"isOffline"`
	// (Updatable) A read-only field showing the IP address/OCID and port that uniquely identify this backend server in the backend set.  Example: `10.0.0.3:8080`, or `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>:443` or `10.0.0.3:0`
	Name pulumi.StringPtrInput `pulumi:"name"`
	// (Updatable) The communication port for the backend server.  Example: `8080`
	Port pulumi.IntInput `pulumi:"port"`
	// (Updatable) The IP OCID/Instance OCID associated with the backend server. Example: `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>`
	TargetId pulumi.StringPtrInput `pulumi:"targetId"`
	// (Updatable) The network load balancing policy weight assigned to the server. Backend servers with a higher weight receive a larger proportion of incoming traffic. For example, a server weighted '3' receives three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/lbpolicies.htm).  Example: `3`
	Weight pulumi.IntPtrInput `pulumi:"weight"`
}

func (NetworkLoadBalancersBackendSetsUnifiedBackendArgs) ElementType 

func (NetworkLoadBalancersBackendSetsUnifiedBackendArgs) ElementType() reflect.Type

func (NetworkLoadBalancersBackendSetsUnifiedBackendArgs) ToNetworkLoadBalancersBackendSetsUnifiedBackendOutput 

func (i NetworkLoadBalancersBackendSetsUnifiedBackendArgs) ToNetworkLoadBalancersBackendSetsUnifiedBackendOutput() NetworkLoadBalancersBackendSetsUnifiedBackendOutput

func (NetworkLoadBalancersBackendSetsUnifiedBackendArgs) ToNetworkLoadBalancersBackendSetsUnifiedBackendOutputWithContext 

func (i NetworkLoadBalancersBackendSetsUnifiedBackendArgs) ToNetworkLoadBalancersBackendSetsUnifiedBackendOutputWithContext(ctx context.Context) NetworkLoadBalancersBackendSetsUnifiedBackendOutput

type NetworkLoadBalancersBackendSetsUnifiedBackendArray 

type NetworkLoadBalancersBackendSetsUnifiedBackendArray []NetworkLoadBalancersBackendSetsUnifiedBackendInput

func (NetworkLoadBalancersBackendSetsUnifiedBackendArray) ElementType 

func (NetworkLoadBalancersBackendSetsUnifiedBackendArray) ElementType() reflect.Type

func (NetworkLoadBalancersBackendSetsUnifiedBackendArray) ToNetworkLoadBalancersBackendSetsUnifiedBackendArrayOutput 

func (i NetworkLoadBalancersBackendSetsUnifiedBackendArray) ToNetworkLoadBalancersBackendSetsUnifiedBackendArrayOutput() NetworkLoadBalancersBackendSetsUnifiedBackendArrayOutput

func (NetworkLoadBalancersBackendSetsUnifiedBackendArray) ToNetworkLoadBalancersBackendSetsUnifiedBackendArrayOutputWithContext 

func (i NetworkLoadBalancersBackendSetsUnifiedBackendArray) ToNetworkLoadBalancersBackendSetsUnifiedBackendArrayOutputWithContext(ctx context.Context) NetworkLoadBalancersBackendSetsUnifiedBackendArrayOutput

type NetworkLoadBalancersBackendSetsUnifiedBackendArrayInput 

type NetworkLoadBalancersBackendSetsUnifiedBackendArrayInput interface {
	pulumi.Input

	ToNetworkLoadBalancersBackendSetsUnifiedBackendArrayOutput() NetworkLoadBalancersBackendSetsUnifiedBackendArrayOutput
	ToNetworkLoadBalancersBackendSetsUnifiedBackendArrayOutputWithContext(context.Context) NetworkLoadBalancersBackendSetsUnifiedBackendArrayOutput
}

NetworkLoadBalancersBackendSetsUnifiedBackendArrayInput is an input type that accepts NetworkLoadBalancersBackendSetsUnifiedBackendArray and NetworkLoadBalancersBackendSetsUnifiedBackendArrayOutput values. You can construct a concrete instance of `NetworkLoadBalancersBackendSetsUnifiedBackendArrayInput` via: 

NetworkLoadBalancersBackendSetsUnifiedBackendArray{ NetworkLoadBalancersBackendSetsUnifiedBackendArgs{...} }

type NetworkLoadBalancersBackendSetsUnifiedBackendArrayOutput 

type NetworkLoadBalancersBackendSetsUnifiedBackendArrayOutput struct{ *pulumi.OutputState }

func (NetworkLoadBalancersBackendSetsUnifiedBackendArrayOutput) ElementType 

func (NetworkLoadBalancersBackendSetsUnifiedBackendArrayOutput) ElementType() reflect.Type

func (NetworkLoadBalancersBackendSetsUnifiedBackendArrayOutput) Index 

func (o NetworkLoadBalancersBackendSetsUnifiedBackendArrayOutput) Index(i pulumi.IntInput) NetworkLoadBalancersBackendSetsUnifiedBackendOutput

func (NetworkLoadBalancersBackendSetsUnifiedBackendArrayOutput) ToNetworkLoadBalancersBackendSetsUnifiedBackendArrayOutput 

func (o NetworkLoadBalancersBackendSetsUnifiedBackendArrayOutput) ToNetworkLoadBalancersBackendSetsUnifiedBackendArrayOutput() NetworkLoadBalancersBackendSetsUnifiedBackendArrayOutput

func (NetworkLoadBalancersBackendSetsUnifiedBackendArrayOutput) ToNetworkLoadBalancersBackendSetsUnifiedBackendArrayOutputWithContext 

func (o NetworkLoadBalancersBackendSetsUnifiedBackendArrayOutput) ToNetworkLoadBalancersBackendSetsUnifiedBackendArrayOutputWithContext(ctx context.Context) NetworkLoadBalancersBackendSetsUnifiedBackendArrayOutput

type NetworkLoadBalancersBackendSetsUnifiedBackendInput 

type NetworkLoadBalancersBackendSetsUnifiedBackendInput interface {
	pulumi.Input

	ToNetworkLoadBalancersBackendSetsUnifiedBackendOutput() NetworkLoadBalancersBackendSetsUnifiedBackendOutput
	ToNetworkLoadBalancersBackendSetsUnifiedBackendOutputWithContext(context.Context) NetworkLoadBalancersBackendSetsUnifiedBackendOutput
}

NetworkLoadBalancersBackendSetsUnifiedBackendInput is an input type that accepts NetworkLoadBalancersBackendSetsUnifiedBackendArgs and NetworkLoadBalancersBackendSetsUnifiedBackendOutput values. You can construct a concrete instance of `NetworkLoadBalancersBackendSetsUnifiedBackendInput` via: 

NetworkLoadBalancersBackendSetsUnifiedBackendArgs{...}

type NetworkLoadBalancersBackendSetsUnifiedBackendOutput 

type NetworkLoadBalancersBackendSetsUnifiedBackendOutput struct{ *pulumi.OutputState }

func (NetworkLoadBalancersBackendSetsUnifiedBackendOutput) ElementType 

func (NetworkLoadBalancersBackendSetsUnifiedBackendOutput) ElementType() reflect.Type

func (NetworkLoadBalancersBackendSetsUnifiedBackendOutput) IpAddress 

func (o NetworkLoadBalancersBackendSetsUnifiedBackendOutput) IpAddress() pulumi.StringPtrOutput

(Updatable) The IP address of the backend server. Example: `10.0.0.3`

func (NetworkLoadBalancersBackendSetsUnifiedBackendOutput) IsBackup 

func (o NetworkLoadBalancersBackendSetsUnifiedBackendOutput) IsBackup() pulumi.BoolPtrOutput

(Updatable) Whether the network load balancer should treat this server as a backup unit. If `true`, then the network load balancer forwards no ingress traffic to this backend server unless all other backend servers not marked as "isBackup" fail the health check policy. Example: `false`

func (NetworkLoadBalancersBackendSetsUnifiedBackendOutput) IsDrain 

func (o NetworkLoadBalancersBackendSetsUnifiedBackendOutput) IsDrain() pulumi.BoolPtrOutput

(Updatable) Whether the network load balancer should drain this server. Servers marked "isDrain" receive no incoming traffic. Example: `false`

func (NetworkLoadBalancersBackendSetsUnifiedBackendOutput) IsOffline 

func (o NetworkLoadBalancersBackendSetsUnifiedBackendOutput) IsOffline() pulumi.BoolPtrOutput

(Updatable) Whether the network load balancer should treat this server as offline. Offline servers receive no incoming traffic. Example: `false`

func (NetworkLoadBalancersBackendSetsUnifiedBackendOutput) Name 

func (o NetworkLoadBalancersBackendSetsUnifiedBackendOutput) Name() pulumi.StringPtrOutput

(Updatable) A read-only field showing the IP address/OCID and port that uniquely identify this backend server in the backend set. Example: `10.0.0.3:8080`, or `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>:443` or `10.0.0.3:0`

func (NetworkLoadBalancersBackendSetsUnifiedBackendOutput) Port 

func (o NetworkLoadBalancersBackendSetsUnifiedBackendOutput) Port() pulumi.IntOutput

(Updatable) The communication port for the backend server. Example: `8080`

func (NetworkLoadBalancersBackendSetsUnifiedBackendOutput) TargetId 

func (o NetworkLoadBalancersBackendSetsUnifiedBackendOutput) TargetId() pulumi.StringPtrOutput

(Updatable) The IP OCID/Instance OCID associated with the backend server. Example: `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>`

func (NetworkLoadBalancersBackendSetsUnifiedBackendOutput) ToNetworkLoadBalancersBackendSetsUnifiedBackendOutput 

func (o NetworkLoadBalancersBackendSetsUnifiedBackendOutput) ToNetworkLoadBalancersBackendSetsUnifiedBackendOutput() NetworkLoadBalancersBackendSetsUnifiedBackendOutput

func (NetworkLoadBalancersBackendSetsUnifiedBackendOutput) ToNetworkLoadBalancersBackendSetsUnifiedBackendOutputWithContext 

func (o NetworkLoadBalancersBackendSetsUnifiedBackendOutput) ToNetworkLoadBalancersBackendSetsUnifiedBackendOutputWithContext(ctx context.Context) NetworkLoadBalancersBackendSetsUnifiedBackendOutput

func (NetworkLoadBalancersBackendSetsUnifiedBackendOutput) Weight 

func (o NetworkLoadBalancersBackendSetsUnifiedBackendOutput) Weight() pulumi.IntPtrOutput

(Updatable) The network load balancing policy weight assigned to the server. Backend servers with a higher weight receive a larger proportion of incoming traffic. For example, a server weighted '3' receives three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/lbpolicies.htm). Example: `3`

type NetworkLoadBalancersBackendSetsUnifiedHealthChecker 

type NetworkLoadBalancersBackendSetsUnifiedHealthChecker struct {
	// (Updatable) DNS healthcheck configurations.
	Dns *NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDns `pulumi:"dns"`
	// (Updatable) The interval between health checks, in milliseconds. The default value is 10000 (10 seconds).  Example: `10000`
	IntervalInMillis *int `pulumi:"intervalInMillis"`
	// (Updatable) The backend server port against which to run the health check. If the port is not specified, then the network load balancer uses the port information from the `Backend` object. The port must be specified if the backend port is 0.  Example: `8080`
	Port *int `pulumi:"port"`
	// (Updatable) The protocol the health check must use; either HTTP or HTTPS, or UDP or TCP.  Example: `HTTP`
	Protocol string `pulumi:"protocol"`
	// (Updatable) Base64 encoded pattern to be sent as UDP or TCP health check probe.
	RequestData *string `pulumi:"requestData"`
	// (Updatable) A regular expression for parsing the response body from the backend server.  Example: `^((?!false).|\s)*$`
	ResponseBodyRegex *string `pulumi:"responseBodyRegex"`
	// (Updatable) Base64 encoded pattern to be validated as UDP or TCP health check probe response.
	ResponseData *string `pulumi:"responseData"`
	// (Updatable) The number of retries to attempt before a backend server is considered "unhealthy". This number also applies when recovering a server to the "healthy" state. The default value is 3.  Example: `3`
	Retries *int `pulumi:"retries"`
	// (Updatable) The status code a healthy backend server should return. If you configure the health check policy to use the HTTP protocol, then you can use common HTTP status codes such as "200".  Example: `200`
	ReturnCode *int `pulumi:"returnCode"`
	// (Updatable) The maximum time, in milliseconds, to wait for a reply to a health check. A health check is successful only if a reply returns within this timeout period. The default value is 3000 (3 seconds).  Example: `3000`
	TimeoutInMillis *int `pulumi:"timeoutInMillis"`
	// (Updatable) The path against which to run the health check.  Example: `/healthcheck`
	UrlPath *string `pulumi:"urlPath"`
}

type NetworkLoadBalancersBackendSetsUnifiedHealthCheckerArgs 

type NetworkLoadBalancersBackendSetsUnifiedHealthCheckerArgs struct {
	// (Updatable) DNS healthcheck configurations.
	Dns NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrInput `pulumi:"dns"`
	// (Updatable) The interval between health checks, in milliseconds. The default value is 10000 (10 seconds).  Example: `10000`
	IntervalInMillis pulumi.IntPtrInput `pulumi:"intervalInMillis"`
	// (Updatable) The backend server port against which to run the health check. If the port is not specified, then the network load balancer uses the port information from the `Backend` object. The port must be specified if the backend port is 0.  Example: `8080`
	Port pulumi.IntPtrInput `pulumi:"port"`
	// (Updatable) The protocol the health check must use; either HTTP or HTTPS, or UDP or TCP.  Example: `HTTP`
	Protocol pulumi.StringInput `pulumi:"protocol"`
	// (Updatable) Base64 encoded pattern to be sent as UDP or TCP health check probe.
	RequestData pulumi.StringPtrInput `pulumi:"requestData"`
	// (Updatable) A regular expression for parsing the response body from the backend server.  Example: `^((?!false).|\s)*$`
	ResponseBodyRegex pulumi.StringPtrInput `pulumi:"responseBodyRegex"`
	// (Updatable) Base64 encoded pattern to be validated as UDP or TCP health check probe response.
	ResponseData pulumi.StringPtrInput `pulumi:"responseData"`
	// (Updatable) The number of retries to attempt before a backend server is considered "unhealthy". This number also applies when recovering a server to the "healthy" state. The default value is 3.  Example: `3`
	Retries pulumi.IntPtrInput `pulumi:"retries"`
	// (Updatable) The status code a healthy backend server should return. If you configure the health check policy to use the HTTP protocol, then you can use common HTTP status codes such as "200".  Example: `200`
	ReturnCode pulumi.IntPtrInput `pulumi:"returnCode"`
	// (Updatable) The maximum time, in milliseconds, to wait for a reply to a health check. A health check is successful only if a reply returns within this timeout period. The default value is 3000 (3 seconds).  Example: `3000`
	TimeoutInMillis pulumi.IntPtrInput `pulumi:"timeoutInMillis"`
	// (Updatable) The path against which to run the health check.  Example: `/healthcheck`
	UrlPath pulumi.StringPtrInput `pulumi:"urlPath"`
}

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerArgs) ElementType 

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerArgs) ElementType() reflect.Type

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerArgs) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput 

func (i NetworkLoadBalancersBackendSetsUnifiedHealthCheckerArgs) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput() NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerArgs) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutputWithContext 

func (i NetworkLoadBalancersBackendSetsUnifiedHealthCheckerArgs) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutputWithContext(ctx context.Context) NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerArgs) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput 

func (i NetworkLoadBalancersBackendSetsUnifiedHealthCheckerArgs) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput() NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerArgs) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutputWithContext 

func (i NetworkLoadBalancersBackendSetsUnifiedHealthCheckerArgs) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutputWithContext(ctx context.Context) NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput

type NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDns 

type NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDns struct {
	// (Updatable) The absolute fully-qualified domain name to perform periodic DNS queries. If not provided, an extra dot will be added at the end of a domain name during the query.
	DomainName string `pulumi:"domainName"`
	// (Updatable) The class the dns health check query to use; either IN or CH.  Example: `IN`
	QueryClass *string `pulumi:"queryClass"`
	// (Updatable) The type the dns health check query to use; A, AAAA, TXT.  Example: `A`
	QueryType *string `pulumi:"queryType"`
	// (Updatable) An array that represents accepetable RCODE values for DNS query response. Example: ["NOERROR", "NXDOMAIN"]
	Rcodes []string `pulumi:"rcodes"`
	// (Updatable) DNS transport protocol; either UDP or TCP.  Example: `UDP`
	TransportProtocol *string `pulumi:"transportProtocol"`
}

type NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsArgs 

type NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsArgs struct {
	// (Updatable) The absolute fully-qualified domain name to perform periodic DNS queries. If not provided, an extra dot will be added at the end of a domain name during the query.
	DomainName pulumi.StringInput `pulumi:"domainName"`
	// (Updatable) The class the dns health check query to use; either IN or CH.  Example: `IN`
	QueryClass pulumi.StringPtrInput `pulumi:"queryClass"`
	// (Updatable) The type the dns health check query to use; A, AAAA, TXT.  Example: `A`
	QueryType pulumi.StringPtrInput `pulumi:"queryType"`
	// (Updatable) An array that represents accepetable RCODE values for DNS query response. Example: ["NOERROR", "NXDOMAIN"]
	Rcodes pulumi.StringArrayInput `pulumi:"rcodes"`
	// (Updatable) DNS transport protocol; either UDP or TCP.  Example: `UDP`
	TransportProtocol pulumi.StringPtrInput `pulumi:"transportProtocol"`
}

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsArgs) ElementType 

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsArgs) ElementType() reflect.Type

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsArgs) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput 

func (i NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsArgs) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput() NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsArgs) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutputWithContext 

func (i NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsArgs) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutputWithContext(ctx context.Context) NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsArgs) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput 

func (i NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsArgs) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput() NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsArgs) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutputWithContext 

func (i NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsArgs) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutputWithContext(ctx context.Context) NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput

type NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsInput 

type NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsInput interface {
	pulumi.Input

	ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput() NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput
	ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutputWithContext(context.Context) NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput
}

NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsInput is an input type that accepts NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsArgs and NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput values. You can construct a concrete instance of `NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsInput` via: 

NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsArgs{...}

type NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput 

type NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput struct{ *pulumi.OutputState }

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput) DomainName 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput) DomainName() pulumi.StringOutput

(Updatable) The absolute fully-qualified domain name to perform periodic DNS queries. If not provided, an extra dot will be added at the end of a domain name during the query.

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput) ElementType 

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput) ElementType() reflect.Type

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput) QueryClass 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput) QueryClass() pulumi.StringPtrOutput

(Updatable) The class the dns health check query to use; either IN or CH. Example: `IN`

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput) QueryType 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput) QueryType() pulumi.StringPtrOutput

(Updatable) The type the dns health check query to use; A, AAAA, TXT. Example: `A`

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput) Rcodes 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput) Rcodes() pulumi.StringArrayOutput

(Updatable) An array that represents accepetable RCODE values for DNS query response. Example: ["NOERROR", "NXDOMAIN"]

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput() NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutputWithContext 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutputWithContext(ctx context.Context) NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput() NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutputWithContext 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutputWithContext(ctx context.Context) NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput) TransportProtocol 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput) TransportProtocol() pulumi.StringPtrOutput

(Updatable) DNS transport protocol; either UDP or TCP. Example: `UDP`

type NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrInput 

type NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrInput interface {
	pulumi.Input

	ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput() NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput
	ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutputWithContext(context.Context) NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput
}

NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrInput is an input type that accepts NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsArgs, NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtr and NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput values. You can construct a concrete instance of `NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrInput` via: 

        NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsArgs{...}

or:

        nil

func NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtr 

func NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtr(v *NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsArgs) NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrInput

type NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput 

type NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput struct{ *pulumi.OutputState }

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput) DomainName 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput) DomainName() pulumi.StringPtrOutput

(Updatable) The absolute fully-qualified domain name to perform periodic DNS queries. If not provided, an extra dot will be added at the end of a domain name during the query.

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput) Elem 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput) Elem() NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsOutput

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput) ElementType 

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput) ElementType() reflect.Type

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput) QueryClass 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput) QueryClass() pulumi.StringPtrOutput

(Updatable) The class the dns health check query to use; either IN or CH. Example: `IN`

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput) QueryType 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput) QueryType() pulumi.StringPtrOutput

(Updatable) The type the dns health check query to use; A, AAAA, TXT. Example: `A`

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput) Rcodes 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput) Rcodes() pulumi.StringArrayOutput

(Updatable) An array that represents accepetable RCODE values for DNS query response. Example: ["NOERROR", "NXDOMAIN"]

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput() NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutputWithContext 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutputWithContext(ctx context.Context) NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput) TransportProtocol 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput) TransportProtocol() pulumi.StringPtrOutput

(Updatable) DNS transport protocol; either UDP or TCP. Example: `UDP`

type NetworkLoadBalancersBackendSetsUnifiedHealthCheckerInput 

type NetworkLoadBalancersBackendSetsUnifiedHealthCheckerInput interface {
	pulumi.Input

	ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput() NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput
	ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutputWithContext(context.Context) NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput
}

NetworkLoadBalancersBackendSetsUnifiedHealthCheckerInput is an input type that accepts NetworkLoadBalancersBackendSetsUnifiedHealthCheckerArgs and NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput values. You can construct a concrete instance of `NetworkLoadBalancersBackendSetsUnifiedHealthCheckerInput` via: 

NetworkLoadBalancersBackendSetsUnifiedHealthCheckerArgs{...}

type NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput 

type NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput struct{ *pulumi.OutputState }

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) Dns 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) Dns() NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput

(Updatable) DNS healthcheck configurations.

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) ElementType 

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) ElementType() reflect.Type

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) IntervalInMillis 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) IntervalInMillis() pulumi.IntPtrOutput

(Updatable) The interval between health checks, in milliseconds. The default value is 10000 (10 seconds). Example: `10000`

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) Port 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) Port() pulumi.IntPtrOutput

(Updatable) The backend server port against which to run the health check. If the port is not specified, then the network load balancer uses the port information from the `Backend` object. The port must be specified if the backend port is 0. Example: `8080`

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) Protocol 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) Protocol() pulumi.StringOutput

(Updatable) The protocol the health check must use; either HTTP or HTTPS, or UDP or TCP. Example: `HTTP`

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) RequestData 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) RequestData() pulumi.StringPtrOutput

(Updatable) Base64 encoded pattern to be sent as UDP or TCP health check probe.

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) ResponseBodyRegex 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) ResponseBodyRegex() pulumi.StringPtrOutput

(Updatable) A regular expression for parsing the response body from the backend server. Example: `^((?!false).|\s)*$`

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) ResponseData 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) ResponseData() pulumi.StringPtrOutput

(Updatable) Base64 encoded pattern to be validated as UDP or TCP health check probe response.

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) Retries 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) Retries() pulumi.IntPtrOutput

(Updatable) The number of retries to attempt before a backend server is considered "unhealthy". This number also applies when recovering a server to the "healthy" state. The default value is 3. Example: `3`

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) ReturnCode 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) ReturnCode() pulumi.IntPtrOutput

(Updatable) The status code a healthy backend server should return. If you configure the health check policy to use the HTTP protocol, then you can use common HTTP status codes such as "200". Example: `200`

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) TimeoutInMillis 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) TimeoutInMillis() pulumi.IntPtrOutput

(Updatable) The maximum time, in milliseconds, to wait for a reply to a health check. A health check is successful only if a reply returns within this timeout period. The default value is 3000 (3 seconds). Example: `3000`

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput() NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutputWithContext 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutputWithContext(ctx context.Context) NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput() NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutputWithContext 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutputWithContext(ctx context.Context) NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) UrlPath 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput) UrlPath() pulumi.StringPtrOutput

(Updatable) The path against which to run the health check. Example: `/healthcheck`

type NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrInput 

type NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrInput interface {
	pulumi.Input

	ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput() NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput
	ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutputWithContext(context.Context) NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput
}

NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrInput is an input type that accepts NetworkLoadBalancersBackendSetsUnifiedHealthCheckerArgs, NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtr and NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput values. You can construct a concrete instance of `NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrInput` via: 

        NetworkLoadBalancersBackendSetsUnifiedHealthCheckerArgs{...}

or:

        nil

func NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtr 

func NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtr(v *NetworkLoadBalancersBackendSetsUnifiedHealthCheckerArgs) NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrInput

type NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput 

type NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput struct{ *pulumi.OutputState }

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) Dns 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) Dns() NetworkLoadBalancersBackendSetsUnifiedHealthCheckerDnsPtrOutput

(Updatable) DNS healthcheck configurations.

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) Elem 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) Elem() NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) ElementType 

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) ElementType() reflect.Type

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) IntervalInMillis 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) IntervalInMillis() pulumi.IntPtrOutput

(Updatable) The interval between health checks, in milliseconds. The default value is 10000 (10 seconds). Example: `10000`

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) Port 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) Port() pulumi.IntPtrOutput

(Updatable) The backend server port against which to run the health check. If the port is not specified, then the network load balancer uses the port information from the `Backend` object. The port must be specified if the backend port is 0. Example: `8080`

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) Protocol 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) Protocol() pulumi.StringPtrOutput

(Updatable) The protocol the health check must use; either HTTP or HTTPS, or UDP or TCP. Example: `HTTP`

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) RequestData 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) RequestData() pulumi.StringPtrOutput

(Updatable) Base64 encoded pattern to be sent as UDP or TCP health check probe.

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) ResponseBodyRegex 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) ResponseBodyRegex() pulumi.StringPtrOutput

(Updatable) A regular expression for parsing the response body from the backend server. Example: `^((?!false).|\s)*$`

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) ResponseData 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) ResponseData() pulumi.StringPtrOutput

(Updatable) Base64 encoded pattern to be validated as UDP or TCP health check probe response.

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) Retries 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) Retries() pulumi.IntPtrOutput

(Updatable) The number of retries to attempt before a backend server is considered "unhealthy". This number also applies when recovering a server to the "healthy" state. The default value is 3. Example: `3`

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) ReturnCode 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) ReturnCode() pulumi.IntPtrOutput

(Updatable) The status code a healthy backend server should return. If you configure the health check policy to use the HTTP protocol, then you can use common HTTP status codes such as "200". Example: `200`

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) TimeoutInMillis 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) TimeoutInMillis() pulumi.IntPtrOutput

(Updatable) The maximum time, in milliseconds, to wait for a reply to a health check. A health check is successful only if a reply returns within this timeout period. The default value is 3000 (3 seconds). Example: `3000`

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput() NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutputWithContext 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) ToNetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutputWithContext(ctx context.Context) NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput

func (NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) UrlPath 

func (o NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrOutput) UrlPath() pulumi.StringPtrOutput

(Updatable) The path against which to run the health check. Example: `/healthcheck`

type NetworkLoadBalancersBackendSetsUnifiedInput 

type NetworkLoadBalancersBackendSetsUnifiedInput interface {
	pulumi.Input

	ToNetworkLoadBalancersBackendSetsUnifiedOutput() NetworkLoadBalancersBackendSetsUnifiedOutput
	ToNetworkLoadBalancersBackendSetsUnifiedOutputWithContext(ctx context.Context) NetworkLoadBalancersBackendSetsUnifiedOutput
}

type NetworkLoadBalancersBackendSetsUnifiedMap 

type NetworkLoadBalancersBackendSetsUnifiedMap map[string]NetworkLoadBalancersBackendSetsUnifiedInput

func (NetworkLoadBalancersBackendSetsUnifiedMap) ElementType 

func (NetworkLoadBalancersBackendSetsUnifiedMap) ElementType() reflect.Type

func (NetworkLoadBalancersBackendSetsUnifiedMap) ToNetworkLoadBalancersBackendSetsUnifiedMapOutput 

func (i NetworkLoadBalancersBackendSetsUnifiedMap) ToNetworkLoadBalancersBackendSetsUnifiedMapOutput() NetworkLoadBalancersBackendSetsUnifiedMapOutput

func (NetworkLoadBalancersBackendSetsUnifiedMap) ToNetworkLoadBalancersBackendSetsUnifiedMapOutputWithContext 

func (i NetworkLoadBalancersBackendSetsUnifiedMap) ToNetworkLoadBalancersBackendSetsUnifiedMapOutputWithContext(ctx context.Context) NetworkLoadBalancersBackendSetsUnifiedMapOutput

type NetworkLoadBalancersBackendSetsUnifiedMapInput 

type NetworkLoadBalancersBackendSetsUnifiedMapInput interface {
	pulumi.Input

	ToNetworkLoadBalancersBackendSetsUnifiedMapOutput() NetworkLoadBalancersBackendSetsUnifiedMapOutput
	ToNetworkLoadBalancersBackendSetsUnifiedMapOutputWithContext(context.Context) NetworkLoadBalancersBackendSetsUnifiedMapOutput
}

NetworkLoadBalancersBackendSetsUnifiedMapInput is an input type that accepts NetworkLoadBalancersBackendSetsUnifiedMap and NetworkLoadBalancersBackendSetsUnifiedMapOutput values. You can construct a concrete instance of `NetworkLoadBalancersBackendSetsUnifiedMapInput` via: 

NetworkLoadBalancersBackendSetsUnifiedMap{ "key": NetworkLoadBalancersBackendSetsUnifiedArgs{...} }

type NetworkLoadBalancersBackendSetsUnifiedMapOutput 

type NetworkLoadBalancersBackendSetsUnifiedMapOutput struct{ *pulumi.OutputState }

func (NetworkLoadBalancersBackendSetsUnifiedMapOutput) ElementType 

func (NetworkLoadBalancersBackendSetsUnifiedMapOutput) ElementType() reflect.Type

func (NetworkLoadBalancersBackendSetsUnifiedMapOutput) MapIndex 

func (o NetworkLoadBalancersBackendSetsUnifiedMapOutput) MapIndex(k pulumi.StringInput) NetworkLoadBalancersBackendSetsUnifiedOutput

func (NetworkLoadBalancersBackendSetsUnifiedMapOutput) ToNetworkLoadBalancersBackendSetsUnifiedMapOutput 

func (o NetworkLoadBalancersBackendSetsUnifiedMapOutput) ToNetworkLoadBalancersBackendSetsUnifiedMapOutput() NetworkLoadBalancersBackendSetsUnifiedMapOutput

func (NetworkLoadBalancersBackendSetsUnifiedMapOutput) ToNetworkLoadBalancersBackendSetsUnifiedMapOutputWithContext 

func (o NetworkLoadBalancersBackendSetsUnifiedMapOutput) ToNetworkLoadBalancersBackendSetsUnifiedMapOutputWithContext(ctx context.Context) NetworkLoadBalancersBackendSetsUnifiedMapOutput

type NetworkLoadBalancersBackendSetsUnifiedOutput 

type NetworkLoadBalancersBackendSetsUnifiedOutput struct{ *pulumi.OutputState }

func (NetworkLoadBalancersBackendSetsUnifiedOutput) Backends 

func (o NetworkLoadBalancersBackendSetsUnifiedOutput) Backends() NetworkLoadBalancersBackendSetsUnifiedBackendArrayOutput

(Updatable) An array of backends to be associated with the backend set.

func (NetworkLoadBalancersBackendSetsUnifiedOutput) ElementType 

func (NetworkLoadBalancersBackendSetsUnifiedOutput) ElementType() reflect.Type

func (NetworkLoadBalancersBackendSetsUnifiedOutput) HealthChecker 

func (o NetworkLoadBalancersBackendSetsUnifiedOutput) HealthChecker() NetworkLoadBalancersBackendSetsUnifiedHealthCheckerOutput

(Updatable) The health check policy configuration. For more information, see [Editing Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/Balance/Tasks/editinghealthcheck.htm).

func (NetworkLoadBalancersBackendSetsUnifiedOutput) IpVersion 

func (o NetworkLoadBalancersBackendSetsUnifiedOutput) IpVersion() pulumi.StringOutput

(Updatable) IP version associated with the backend set.

func (NetworkLoadBalancersBackendSetsUnifiedOutput) IsFailOpen 

func (o NetworkLoadBalancersBackendSetsUnifiedOutput) IsFailOpen() pulumi.BoolOutput

(Updatable) If enabled, the network load balancer will continue to distribute traffic in the configured distribution in the event all backends are unhealthy. The value is false by default.

func (NetworkLoadBalancersBackendSetsUnifiedOutput) IsInstantFailoverEnabled 

func (o NetworkLoadBalancersBackendSetsUnifiedOutput) IsInstantFailoverEnabled() pulumi.BoolOutput

(Updatable) If enabled existing connections will be forwarded to an alternative healthy backend as soon as current backend becomes unhealthy.

func (NetworkLoadBalancersBackendSetsUnifiedOutput) IsPreserveSource 

func (o NetworkLoadBalancersBackendSetsUnifiedOutput) IsPreserveSource() pulumi.BoolOutput

(Updatable) If this parameter is enabled, then the network load balancer preserves the source IP of the packet when it is forwarded to backends. Backends see the original source IP. If the isPreserveSourceDestination parameter is enabled for the network load balancer resource, then this parameter cannot be disabled. The value is true by default.

func (NetworkLoadBalancersBackendSetsUnifiedOutput) Name 

func (o NetworkLoadBalancersBackendSetsUnifiedOutput) Name() pulumi.StringOutput

A user-friendly name for the backend set that must be unique and cannot be changed.

Valid backend set names include only alphanumeric characters, dashes, and underscores. Backend set names cannot contain spaces. Avoid entering confidential information.

Example: `exampleBackendSet`

func (NetworkLoadBalancersBackendSetsUnifiedOutput) NetworkLoadBalancerId 

func (o NetworkLoadBalancersBackendSetsUnifiedOutput) NetworkLoadBalancerId() pulumi.StringOutput

The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.

func (NetworkLoadBalancersBackendSetsUnifiedOutput) Policy 

func (o NetworkLoadBalancersBackendSetsUnifiedOutput) Policy() pulumi.StringOutput

(Updatable) The network load balancer policy for the backend set. Example: `FIVE_TUPLE“

** IMPORTANT ** Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values

func (NetworkLoadBalancersBackendSetsUnifiedOutput) ToNetworkLoadBalancersBackendSetsUnifiedOutput 

func (o NetworkLoadBalancersBackendSetsUnifiedOutput) ToNetworkLoadBalancersBackendSetsUnifiedOutput() NetworkLoadBalancersBackendSetsUnifiedOutput

func (NetworkLoadBalancersBackendSetsUnifiedOutput) ToNetworkLoadBalancersBackendSetsUnifiedOutputWithContext 

func (o NetworkLoadBalancersBackendSetsUnifiedOutput) ToNetworkLoadBalancersBackendSetsUnifiedOutputWithContext(ctx context.Context) NetworkLoadBalancersBackendSetsUnifiedOutput

type NetworkLoadBalancersBackendSetsUnifiedState 

type NetworkLoadBalancersBackendSetsUnifiedState struct {
	// (Updatable) An array of backends to be associated with the backend set.
	Backends NetworkLoadBalancersBackendSetsUnifiedBackendArrayInput
	// (Updatable) The health check policy configuration. For more information, see [Editing Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/Balance/Tasks/editinghealthcheck.htm).
	HealthChecker NetworkLoadBalancersBackendSetsUnifiedHealthCheckerPtrInput
	// (Updatable) IP version associated with the backend set.
	IpVersion pulumi.StringPtrInput
	// (Updatable) If enabled, the network load balancer will continue to distribute traffic in the configured distribution in the event all backends are unhealthy. The value is false by default.
	IsFailOpen pulumi.BoolPtrInput
	// (Updatable) If enabled existing connections will be forwarded to an alternative healthy backend as soon as current backend becomes unhealthy.
	IsInstantFailoverEnabled pulumi.BoolPtrInput
	// (Updatable) If this parameter is enabled, then the network load balancer preserves the source IP of the packet when it is forwarded to backends. Backends see the original source IP. If the isPreserveSourceDestination parameter is enabled for the network load balancer resource, then this parameter cannot be disabled. The value is true by default.
	IsPreserveSource pulumi.BoolPtrInput
	// A user-friendly name for the backend set that must be unique and cannot be changed.
	//
	// Valid backend set names include only alphanumeric characters, dashes, and underscores. Backend set names cannot contain spaces. Avoid entering confidential information.
	//
	// Example: `exampleBackendSet`
	Name pulumi.StringPtrInput
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
	NetworkLoadBalancerId pulumi.StringPtrInput
	// (Updatable) The network load balancer policy for the backend set.  Example: `FIVE_TUPLE“
	//
	// ** IMPORTANT **
	// Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
	Policy pulumi.StringPtrInput
}

func (NetworkLoadBalancersBackendSetsUnifiedState) ElementType 

func (NetworkLoadBalancersBackendSetsUnifiedState) 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.