backendSet.go

// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT.
// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***

package loadbalancer

import (
	"context"
	"reflect"

	"errors"
	"github.com/pulumi/pulumi-oci/sdk/go/oci/internal"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

// This resource provides the Backend Set resource in Oracle Cloud Infrastructure Load Balancer service.
//
// Adds a backend set to a load balancer.
//
// ## Supported Aliases
//
// * `ociLoadBalancerBackendset`
//
// ## Example Usage
//
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-oci/sdk/go/oci/LoadBalancer"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			_, err := LoadBalancer.NewBackendSet(ctx, "test_backend_set", &LoadBalancer.BackendSetArgs{
//				HealthChecker: &loadbalancer.BackendSetHealthCheckerArgs{
//					Protocol:          pulumi.Any(backendSetHealthCheckerProtocol),
//					IntervalMs:        pulumi.Any(backendSetHealthCheckerIntervalMs),
//					IsForcePlainText:  pulumi.Any(backendSetHealthCheckerIsForcePlainText),
//					Port:              pulumi.Any(backendSetHealthCheckerPort),
//					ResponseBodyRegex: pulumi.Any(backendSetHealthCheckerResponseBodyRegex),
//					Retries:           pulumi.Any(backendSetHealthCheckerRetries),
//					ReturnCode:        pulumi.Any(backendSetHealthCheckerReturnCode),
//					TimeoutInMillis:   pulumi.Any(backendSetHealthCheckerTimeoutInMillis),
//					UrlPath:           pulumi.Any(backendSetHealthCheckerUrlPath),
//				},
//				LoadBalancerId: pulumi.Any(testLoadBalancer.Id),
//				Name:           pulumi.Any(backendSetName),
//				Policy:         pulumi.Any(backendSetPolicy),
//				LbCookieSessionPersistenceConfiguration: &loadbalancer.BackendSetLbCookieSessionPersistenceConfigurationArgs{
//					CookieName:      pulumi.Any(backendSetLbCookieSessionPersistenceConfigurationCookieName),
//					DisableFallback: pulumi.Any(backendSetLbCookieSessionPersistenceConfigurationDisableFallback),
//					Domain:          pulumi.Any(backendSetLbCookieSessionPersistenceConfigurationDomain),
//					IsHttpOnly:      pulumi.Any(backendSetLbCookieSessionPersistenceConfigurationIsHttpOnly),
//					IsSecure:        pulumi.Any(backendSetLbCookieSessionPersistenceConfigurationIsSecure),
//					MaxAgeInSeconds: pulumi.Any(backendSetLbCookieSessionPersistenceConfigurationMaxAgeInSeconds),
//					Path:            pulumi.Any(backendSetLbCookieSessionPersistenceConfigurationPath),
//				},
//				SessionPersistenceConfiguration: &loadbalancer.BackendSetSessionPersistenceConfigurationArgs{
//					CookieName:      pulumi.Any(backendSetSessionPersistenceConfigurationCookieName),
//					DisableFallback: pulumi.Any(backendSetSessionPersistenceConfigurationDisableFallback),
//				},
//				SslConfiguration: &loadbalancer.BackendSetSslConfigurationArgs{
//					CertificateIds:                 pulumi.Any(backendSetSslConfigurationCertificateIds),
//					CertificateName:                pulumi.Any(testCertificate.Name),
//					CipherSuiteName:                pulumi.Any(backendSetSslConfigurationCipherSuiteName),
//					Protocols:                      pulumi.Any(backendSetSslConfigurationProtocols),
//					ServerOrderPreference:          pulumi.Any(backendSetSslConfigurationServerOrderPreference),
//					TrustedCertificateAuthorityIds: pulumi.Any(backendSetSslConfigurationTrustedCertificateAuthorityIds),
//					VerifyDepth:                    pulumi.Any(backendSetSslConfigurationVerifyDepth),
//					VerifyPeerCertificate:          pulumi.Any(backendSetSslConfigurationVerifyPeerCertificate),
//				},
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// **Note:** The `sessionPersistenceConfiguration` (application cookie stickiness) and `lbCookieSessionPersistenceConfiguration`
//
//	(LB cookie stickiness) attributes are mutually exclusive. To avoid returning an error, configure only one of these two
//	attributes per backend set.
//
// ## Import
//
// BackendSets can be imported using the `id`, e.g.
//
// ```sh
// $ pulumi import oci:LoadBalancer/backendSet:BackendSet test_backend_set "loadBalancers/{loadBalancerId}/backendSets/{backendSetName}"
// ```
type BackendSet struct {
	pulumi.CustomResourceState

	Backends BackendSetBackendArrayOutput `pulumi:"backends"`
	// (Updatable) The health check policy's configuration details.
	HealthChecker BackendSetHealthCheckerOutput `pulumi:"healthChecker"`
	// (Updatable) The configuration details for implementing load balancer cookie session persistence (LB cookie stickiness).
	//
	// Session persistence enables the Load Balancing service to direct all requests that originate from a single logical client to a single backend web server. For more information, see [Session Persistence](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/sessionpersistence.htm).
	//
	// When you configure LB cookie stickiness, the load balancer inserts a cookie into the response. The parameters configured in the cookie enable session stickiness. This method is useful when you have applications and Web backend services that cannot generate their own cookies.
	//
	// Path route rules take precedence to determine the target backend server. The load balancer verifies that session stickiness is enabled for the backend server and that the cookie configuration (domain, path, and cookie hash) is valid for the target. The system ignores invalid cookies.
	//
	// To disable LB cookie stickiness on a running load balancer, use the [UpdateBackendSet](https://docs.cloud.oracle.com/iaas/api/#/en/loadbalancer/20170115/BackendSet/UpdateBackendSet) operation and specify `null` for the `LBCookieSessionPersistenceConfigurationDetails` object.
	//
	// Example: `LBCookieSessionPersistenceConfigurationDetails: null`
	//
	// **Note:** `SessionPersistenceConfigurationDetails` (application cookie stickiness) and `LBCookieSessionPersistenceConfigurationDetails` (LB cookie stickiness) are mutually exclusive. An error results if you try to enable both types of session persistence.
	//
	// **Warning:** Oracle recommends that you avoid using any confidential information when you supply string values using the API.
	LbCookieSessionPersistenceConfiguration BackendSetLbCookieSessionPersistenceConfigurationOutput `pulumi:"lbCookieSessionPersistenceConfiguration"`
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the load balancer on which to add a backend set.
	LoadBalancerId pulumi.StringOutput `pulumi:"loadBalancerId"`
	// A friendly name for the backend set. It must be unique and it 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"`
	// (Updatable) The load balancer policy for the backend set. To get a list of available policies, use the [ListPolicies](https://docs.cloud.oracle.com/iaas/api/#/en/loadbalancer/20170115/LoadBalancerPolicy/ListPolicies) operation.  Example: `LEAST_CONNECTIONS`
	Policy pulumi.StringOutput `pulumi:"policy"`
	// (Updatable) The configuration details for implementing session persistence based on a user-specified cookie name (application cookie stickiness).
	//
	// Session persistence enables the Load Balancing service to direct any number of requests that originate from a single logical client to a single backend web server. For more information, see [Session Persistence](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/sessionpersistence.htm).
	//
	// With application cookie stickiness, the load balancer enables session persistence only when the response from a backend application server includes a `Set-cookie` header with the user-specified cookie name.
	//
	// To disable application cookie stickiness on a running load balancer, use the [UpdateBackendSet](https://docs.cloud.oracle.com/iaas/api/#/en/loadbalancer/20170115/BackendSet/UpdateBackendSet) operation and specify `null` for the `SessionPersistenceConfigurationDetails` object.
	//
	// Example: `SessionPersistenceConfigurationDetails: null`
	//
	// **Note:** `SessionPersistenceConfigurationDetails` (application cookie stickiness) and `LBCookieSessionPersistenceConfigurationDetails` (LB cookie stickiness) are mutually exclusive. An error results if you try to enable both types of session persistence.
	//
	// **Warning:** Oracle recommends that you avoid using any confidential information when you supply string values using the API.
	SessionPersistenceConfiguration BackendSetSessionPersistenceConfigurationOutput `pulumi:"sessionPersistenceConfiguration"`
	// (Updatable) The load balancer's SSL handling configuration details.
	//
	// **Warning:** Oracle recommends that you avoid using any confidential information when you supply string values using the API.
	SslConfiguration BackendSetSslConfigurationPtrOutput `pulumi:"sslConfiguration"`
	State            pulumi.StringOutput                 `pulumi:"state"`
}

// NewBackendSet registers a new resource with the given unique name, arguments, and options.
func NewBackendSet(ctx *pulumi.Context,
	name string, args *BackendSetArgs, opts ...pulumi.ResourceOption) (*BackendSet, error) {
	if args == nil {
		return nil, errors.New("missing one or more required arguments")
	}

	if args.HealthChecker == nil {
		return nil, errors.New("invalid value for required argument 'HealthChecker'")
	}
	if args.LoadBalancerId == nil {
		return nil, errors.New("invalid value for required argument 'LoadBalancerId'")
	}
	if args.Policy == nil {
		return nil, errors.New("invalid value for required argument 'Policy'")
	}
	opts = internal.PkgResourceDefaultOpts(opts)
	var resource BackendSet
	err := ctx.RegisterResource("oci:LoadBalancer/backendSet:BackendSet", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// 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 GetBackendSet(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *BackendSetState, opts ...pulumi.ResourceOption) (*BackendSet, error) {
	var resource BackendSet
	err := ctx.ReadResource("oci:LoadBalancer/backendSet:BackendSet", name, id, state, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// Input properties used for looking up and filtering BackendSet resources.
type backendSetState struct {
	Backends []BackendSetBackend `pulumi:"backends"`
	// (Updatable) The health check policy's configuration details.
	HealthChecker *BackendSetHealthChecker `pulumi:"healthChecker"`
	// (Updatable) The configuration details for implementing load balancer cookie session persistence (LB cookie stickiness).
	//
	// Session persistence enables the Load Balancing service to direct all requests that originate from a single logical client to a single backend web server. For more information, see [Session Persistence](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/sessionpersistence.htm).
	//
	// When you configure LB cookie stickiness, the load balancer inserts a cookie into the response. The parameters configured in the cookie enable session stickiness. This method is useful when you have applications and Web backend services that cannot generate their own cookies.
	//
	// Path route rules take precedence to determine the target backend server. The load balancer verifies that session stickiness is enabled for the backend server and that the cookie configuration (domain, path, and cookie hash) is valid for the target. The system ignores invalid cookies.
	//
	// To disable LB cookie stickiness on a running load balancer, use the [UpdateBackendSet](https://docs.cloud.oracle.com/iaas/api/#/en/loadbalancer/20170115/BackendSet/UpdateBackendSet) operation and specify `null` for the `LBCookieSessionPersistenceConfigurationDetails` object.
	//
	// Example: `LBCookieSessionPersistenceConfigurationDetails: null`
	//
	// **Note:** `SessionPersistenceConfigurationDetails` (application cookie stickiness) and `LBCookieSessionPersistenceConfigurationDetails` (LB cookie stickiness) are mutually exclusive. An error results if you try to enable both types of session persistence.
	//
	// **Warning:** Oracle recommends that you avoid using any confidential information when you supply string values using the API.
	LbCookieSessionPersistenceConfiguration *BackendSetLbCookieSessionPersistenceConfiguration `pulumi:"lbCookieSessionPersistenceConfiguration"`
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the load balancer on which to add a backend set.
	LoadBalancerId *string `pulumi:"loadBalancerId"`
	// A friendly name for the backend set. It must be unique and it 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 *string `pulumi:"name"`
	// (Updatable) The load balancer policy for the backend set. To get a list of available policies, use the [ListPolicies](https://docs.cloud.oracle.com/iaas/api/#/en/loadbalancer/20170115/LoadBalancerPolicy/ListPolicies) operation.  Example: `LEAST_CONNECTIONS`
	Policy *string `pulumi:"policy"`
	// (Updatable) The configuration details for implementing session persistence based on a user-specified cookie name (application cookie stickiness).
	//
	// Session persistence enables the Load Balancing service to direct any number of requests that originate from a single logical client to a single backend web server. For more information, see [Session Persistence](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/sessionpersistence.htm).
	//
	// With application cookie stickiness, the load balancer enables session persistence only when the response from a backend application server includes a `Set-cookie` header with the user-specified cookie name.
	//
	// To disable application cookie stickiness on a running load balancer, use the [UpdateBackendSet](https://docs.cloud.oracle.com/iaas/api/#/en/loadbalancer/20170115/BackendSet/UpdateBackendSet) operation and specify `null` for the `SessionPersistenceConfigurationDetails` object.
	//
	// Example: `SessionPersistenceConfigurationDetails: null`
	//
	// **Note:** `SessionPersistenceConfigurationDetails` (application cookie stickiness) and `LBCookieSessionPersistenceConfigurationDetails` (LB cookie stickiness) are mutually exclusive. An error results if you try to enable both types of session persistence.
	//
	// **Warning:** Oracle recommends that you avoid using any confidential information when you supply string values using the API.
	SessionPersistenceConfiguration *BackendSetSessionPersistenceConfiguration `pulumi:"sessionPersistenceConfiguration"`
	// (Updatable) The load balancer's SSL handling configuration details.
	//
	// **Warning:** Oracle recommends that you avoid using any confidential information when you supply string values using the API.
	SslConfiguration *BackendSetSslConfiguration `pulumi:"sslConfiguration"`
	State            *string                     `pulumi:"state"`
}

type BackendSetState struct {
	Backends BackendSetBackendArrayInput
	// (Updatable) The health check policy's configuration details.
	HealthChecker BackendSetHealthCheckerPtrInput
	// (Updatable) The configuration details for implementing load balancer cookie session persistence (LB cookie stickiness).
	//
	// Session persistence enables the Load Balancing service to direct all requests that originate from a single logical client to a single backend web server. For more information, see [Session Persistence](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/sessionpersistence.htm).
	//
	// When you configure LB cookie stickiness, the load balancer inserts a cookie into the response. The parameters configured in the cookie enable session stickiness. This method is useful when you have applications and Web backend services that cannot generate their own cookies.
	//
	// Path route rules take precedence to determine the target backend server. The load balancer verifies that session stickiness is enabled for the backend server and that the cookie configuration (domain, path, and cookie hash) is valid for the target. The system ignores invalid cookies.
	//
	// To disable LB cookie stickiness on a running load balancer, use the [UpdateBackendSet](https://docs.cloud.oracle.com/iaas/api/#/en/loadbalancer/20170115/BackendSet/UpdateBackendSet) operation and specify `null` for the `LBCookieSessionPersistenceConfigurationDetails` object.
	//
	// Example: `LBCookieSessionPersistenceConfigurationDetails: null`
	//
	// **Note:** `SessionPersistenceConfigurationDetails` (application cookie stickiness) and `LBCookieSessionPersistenceConfigurationDetails` (LB cookie stickiness) are mutually exclusive. An error results if you try to enable both types of session persistence.
	//
	// **Warning:** Oracle recommends that you avoid using any confidential information when you supply string values using the API.
	LbCookieSessionPersistenceConfiguration BackendSetLbCookieSessionPersistenceConfigurationPtrInput
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the load balancer on which to add a backend set.
	LoadBalancerId pulumi.StringPtrInput
	// A friendly name for the backend set. It must be unique and it 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
	// (Updatable) The load balancer policy for the backend set. To get a list of available policies, use the [ListPolicies](https://docs.cloud.oracle.com/iaas/api/#/en/loadbalancer/20170115/LoadBalancerPolicy/ListPolicies) operation.  Example: `LEAST_CONNECTIONS`
	Policy pulumi.StringPtrInput
	// (Updatable) The configuration details for implementing session persistence based on a user-specified cookie name (application cookie stickiness).
	//
	// Session persistence enables the Load Balancing service to direct any number of requests that originate from a single logical client to a single backend web server. For more information, see [Session Persistence](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/sessionpersistence.htm).
	//
	// With application cookie stickiness, the load balancer enables session persistence only when the response from a backend application server includes a `Set-cookie` header with the user-specified cookie name.
	//
	// To disable application cookie stickiness on a running load balancer, use the [UpdateBackendSet](https://docs.cloud.oracle.com/iaas/api/#/en/loadbalancer/20170115/BackendSet/UpdateBackendSet) operation and specify `null` for the `SessionPersistenceConfigurationDetails` object.
	//
	// Example: `SessionPersistenceConfigurationDetails: null`
	//
	// **Note:** `SessionPersistenceConfigurationDetails` (application cookie stickiness) and `LBCookieSessionPersistenceConfigurationDetails` (LB cookie stickiness) are mutually exclusive. An error results if you try to enable both types of session persistence.
	//
	// **Warning:** Oracle recommends that you avoid using any confidential information when you supply string values using the API.
	SessionPersistenceConfiguration BackendSetSessionPersistenceConfigurationPtrInput
	// (Updatable) The load balancer's SSL handling configuration details.
	//
	// **Warning:** Oracle recommends that you avoid using any confidential information when you supply string values using the API.
	SslConfiguration BackendSetSslConfigurationPtrInput
	State            pulumi.StringPtrInput
}

func (BackendSetState) ElementType() reflect.Type {
	return reflect.TypeOf((*backendSetState)(nil)).Elem()
}

type backendSetArgs struct {
	// (Updatable) The health check policy's configuration details.
	HealthChecker BackendSetHealthChecker `pulumi:"healthChecker"`
	// (Updatable) The configuration details for implementing load balancer cookie session persistence (LB cookie stickiness).
	//
	// Session persistence enables the Load Balancing service to direct all requests that originate from a single logical client to a single backend web server. For more information, see [Session Persistence](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/sessionpersistence.htm).
	//
	// When you configure LB cookie stickiness, the load balancer inserts a cookie into the response. The parameters configured in the cookie enable session stickiness. This method is useful when you have applications and Web backend services that cannot generate their own cookies.
	//
	// Path route rules take precedence to determine the target backend server. The load balancer verifies that session stickiness is enabled for the backend server and that the cookie configuration (domain, path, and cookie hash) is valid for the target. The system ignores invalid cookies.
	//
	// To disable LB cookie stickiness on a running load balancer, use the [UpdateBackendSet](https://docs.cloud.oracle.com/iaas/api/#/en/loadbalancer/20170115/BackendSet/UpdateBackendSet) operation and specify `null` for the `LBCookieSessionPersistenceConfigurationDetails` object.
	//
	// Example: `LBCookieSessionPersistenceConfigurationDetails: null`
	//
	// **Note:** `SessionPersistenceConfigurationDetails` (application cookie stickiness) and `LBCookieSessionPersistenceConfigurationDetails` (LB cookie stickiness) are mutually exclusive. An error results if you try to enable both types of session persistence.
	//
	// **Warning:** Oracle recommends that you avoid using any confidential information when you supply string values using the API.
	LbCookieSessionPersistenceConfiguration *BackendSetLbCookieSessionPersistenceConfiguration `pulumi:"lbCookieSessionPersistenceConfiguration"`
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the load balancer on which to add a backend set.
	LoadBalancerId string `pulumi:"loadBalancerId"`
	// A friendly name for the backend set. It must be unique and it 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 *string `pulumi:"name"`
	// (Updatable) The load balancer policy for the backend set. To get a list of available policies, use the [ListPolicies](https://docs.cloud.oracle.com/iaas/api/#/en/loadbalancer/20170115/LoadBalancerPolicy/ListPolicies) operation.  Example: `LEAST_CONNECTIONS`
	Policy string `pulumi:"policy"`
	// (Updatable) The configuration details for implementing session persistence based on a user-specified cookie name (application cookie stickiness).
	//
	// Session persistence enables the Load Balancing service to direct any number of requests that originate from a single logical client to a single backend web server. For more information, see [Session Persistence](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/sessionpersistence.htm).
	//
	// With application cookie stickiness, the load balancer enables session persistence only when the response from a backend application server includes a `Set-cookie` header with the user-specified cookie name.
	//
	// To disable application cookie stickiness on a running load balancer, use the [UpdateBackendSet](https://docs.cloud.oracle.com/iaas/api/#/en/loadbalancer/20170115/BackendSet/UpdateBackendSet) operation and specify `null` for the `SessionPersistenceConfigurationDetails` object.
	//
	// Example: `SessionPersistenceConfigurationDetails: null`
	//
	// **Note:** `SessionPersistenceConfigurationDetails` (application cookie stickiness) and `LBCookieSessionPersistenceConfigurationDetails` (LB cookie stickiness) are mutually exclusive. An error results if you try to enable both types of session persistence.
	//
	// **Warning:** Oracle recommends that you avoid using any confidential information when you supply string values using the API.
	SessionPersistenceConfiguration *BackendSetSessionPersistenceConfiguration `pulumi:"sessionPersistenceConfiguration"`
	// (Updatable) The load balancer's SSL handling configuration details.
	//
	// **Warning:** Oracle recommends that you avoid using any confidential information when you supply string values using the API.
	SslConfiguration *BackendSetSslConfiguration `pulumi:"sslConfiguration"`
}

// The set of arguments for constructing a BackendSet resource.
type BackendSetArgs struct {
	// (Updatable) The health check policy's configuration details.
	HealthChecker BackendSetHealthCheckerInput
	// (Updatable) The configuration details for implementing load balancer cookie session persistence (LB cookie stickiness).
	//
	// Session persistence enables the Load Balancing service to direct all requests that originate from a single logical client to a single backend web server. For more information, see [Session Persistence](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/sessionpersistence.htm).
	//
	// When you configure LB cookie stickiness, the load balancer inserts a cookie into the response. The parameters configured in the cookie enable session stickiness. This method is useful when you have applications and Web backend services that cannot generate their own cookies.
	//
	// Path route rules take precedence to determine the target backend server. The load balancer verifies that session stickiness is enabled for the backend server and that the cookie configuration (domain, path, and cookie hash) is valid for the target. The system ignores invalid cookies.
	//
	// To disable LB cookie stickiness on a running load balancer, use the [UpdateBackendSet](https://docs.cloud.oracle.com/iaas/api/#/en/loadbalancer/20170115/BackendSet/UpdateBackendSet) operation and specify `null` for the `LBCookieSessionPersistenceConfigurationDetails` object.
	//
	// Example: `LBCookieSessionPersistenceConfigurationDetails: null`
	//
	// **Note:** `SessionPersistenceConfigurationDetails` (application cookie stickiness) and `LBCookieSessionPersistenceConfigurationDetails` (LB cookie stickiness) are mutually exclusive. An error results if you try to enable both types of session persistence.
	//
	// **Warning:** Oracle recommends that you avoid using any confidential information when you supply string values using the API.
	LbCookieSessionPersistenceConfiguration BackendSetLbCookieSessionPersistenceConfigurationPtrInput
	// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the load balancer on which to add a backend set.
	LoadBalancerId pulumi.StringInput
	// A friendly name for the backend set. It must be unique and it 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
	// (Updatable) The load balancer policy for the backend set. To get a list of available policies, use the [ListPolicies](https://docs.cloud.oracle.com/iaas/api/#/en/loadbalancer/20170115/LoadBalancerPolicy/ListPolicies) operation.  Example: `LEAST_CONNECTIONS`
	Policy pulumi.StringInput
	// (Updatable) The configuration details for implementing session persistence based on a user-specified cookie name (application cookie stickiness).
	//
	// Session persistence enables the Load Balancing service to direct any number of requests that originate from a single logical client to a single backend web server. For more information, see [Session Persistence](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/sessionpersistence.htm).
	//
	// With application cookie stickiness, the load balancer enables session persistence only when the response from a backend application server includes a `Set-cookie` header with the user-specified cookie name.
	//
	// To disable application cookie stickiness on a running load balancer, use the [UpdateBackendSet](https://docs.cloud.oracle.com/iaas/api/#/en/loadbalancer/20170115/BackendSet/UpdateBackendSet) operation and specify `null` for the `SessionPersistenceConfigurationDetails` object.
	//
	// Example: `SessionPersistenceConfigurationDetails: null`
	//
	// **Note:** `SessionPersistenceConfigurationDetails` (application cookie stickiness) and `LBCookieSessionPersistenceConfigurationDetails` (LB cookie stickiness) are mutually exclusive. An error results if you try to enable both types of session persistence.
	//
	// **Warning:** Oracle recommends that you avoid using any confidential information when you supply string values using the API.
	SessionPersistenceConfiguration BackendSetSessionPersistenceConfigurationPtrInput
	// (Updatable) The load balancer's SSL handling configuration details.
	//
	// **Warning:** Oracle recommends that you avoid using any confidential information when you supply string values using the API.
	SslConfiguration BackendSetSslConfigurationPtrInput
}

func (BackendSetArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*backendSetArgs)(nil)).Elem()
}

type BackendSetInput interface {
	pulumi.Input

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

func (*BackendSet) ElementType() reflect.Type {
	return reflect.TypeOf((**BackendSet)(nil)).Elem()
}

func (i *BackendSet) ToBackendSetOutput() BackendSetOutput {
	return i.ToBackendSetOutputWithContext(context.Background())
}

func (i *BackendSet) ToBackendSetOutputWithContext(ctx context.Context) BackendSetOutput {
	return pulumi.ToOutputWithContext(ctx, i).(BackendSetOutput)
}

// BackendSetArrayInput is an input type that accepts BackendSetArray and BackendSetArrayOutput values.
// You can construct a concrete instance of `BackendSetArrayInput` via:
//
//	BackendSetArray{ BackendSetArgs{...} }
type BackendSetArrayInput interface {
	pulumi.Input

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

type BackendSetArray []BackendSetInput

func (BackendSetArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]*BackendSet)(nil)).Elem()
}

func (i BackendSetArray) ToBackendSetArrayOutput() BackendSetArrayOutput {
	return i.ToBackendSetArrayOutputWithContext(context.Background())
}

func (i BackendSetArray) ToBackendSetArrayOutputWithContext(ctx context.Context) BackendSetArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(BackendSetArrayOutput)
}

// BackendSetMapInput is an input type that accepts BackendSetMap and BackendSetMapOutput values.
// You can construct a concrete instance of `BackendSetMapInput` via:
//
//	BackendSetMap{ "key": BackendSetArgs{...} }
type BackendSetMapInput interface {
	pulumi.Input

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

type BackendSetMap map[string]BackendSetInput

func (BackendSetMap) ElementType() reflect.Type {
	return reflect.TypeOf((*map[string]*BackendSet)(nil)).Elem()
}

func (i BackendSetMap) ToBackendSetMapOutput() BackendSetMapOutput {
	return i.ToBackendSetMapOutputWithContext(context.Background())
}

func (i BackendSetMap) ToBackendSetMapOutputWithContext(ctx context.Context) BackendSetMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(BackendSetMapOutput)
}

type BackendSetOutput struct{ *pulumi.OutputState }

func (BackendSetOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**BackendSet)(nil)).Elem()
}

func (o BackendSetOutput) ToBackendSetOutput() BackendSetOutput {
	return o
}

func (o BackendSetOutput) ToBackendSetOutputWithContext(ctx context.Context) BackendSetOutput {
	return o
}

func (o BackendSetOutput) Backends() BackendSetBackendArrayOutput {
	return o.ApplyT(func(v *BackendSet) BackendSetBackendArrayOutput { return v.Backends }).(BackendSetBackendArrayOutput)
}

// (Updatable) The health check policy's configuration details.
func (o BackendSetOutput) HealthChecker() BackendSetHealthCheckerOutput {
	return o.ApplyT(func(v *BackendSet) BackendSetHealthCheckerOutput { return v.HealthChecker }).(BackendSetHealthCheckerOutput)
}

// (Updatable) The configuration details for implementing load balancer cookie session persistence (LB cookie stickiness).
//
// Session persistence enables the Load Balancing service to direct all requests that originate from a single logical client to a single backend web server. For more information, see [Session Persistence](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/sessionpersistence.htm).
//
// When you configure LB cookie stickiness, the load balancer inserts a cookie into the response. The parameters configured in the cookie enable session stickiness. This method is useful when you have applications and Web backend services that cannot generate their own cookies.
//
// Path route rules take precedence to determine the target backend server. The load balancer verifies that session stickiness is enabled for the backend server and that the cookie configuration (domain, path, and cookie hash) is valid for the target. The system ignores invalid cookies.
//
// To disable LB cookie stickiness on a running load balancer, use the [UpdateBackendSet](https://docs.cloud.oracle.com/iaas/api/#/en/loadbalancer/20170115/BackendSet/UpdateBackendSet) operation and specify `null` for the `LBCookieSessionPersistenceConfigurationDetails` object.
//
// Example: `LBCookieSessionPersistenceConfigurationDetails: null`
//
// **Note:** `SessionPersistenceConfigurationDetails` (application cookie stickiness) and `LBCookieSessionPersistenceConfigurationDetails` (LB cookie stickiness) are mutually exclusive. An error results if you try to enable both types of session persistence.
//
// **Warning:** Oracle recommends that you avoid using any confidential information when you supply string values using the API.
func (o BackendSetOutput) LbCookieSessionPersistenceConfiguration() BackendSetLbCookieSessionPersistenceConfigurationOutput {
	return o.ApplyT(func(v *BackendSet) BackendSetLbCookieSessionPersistenceConfigurationOutput {
		return v.LbCookieSessionPersistenceConfiguration
	}).(BackendSetLbCookieSessionPersistenceConfigurationOutput)
}

// The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the load balancer on which to add a backend set.
func (o BackendSetOutput) LoadBalancerId() pulumi.StringOutput {
	return o.ApplyT(func(v *BackendSet) pulumi.StringOutput { return v.LoadBalancerId }).(pulumi.StringOutput)
}

// A friendly name for the backend set. It must be unique and it 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 (o BackendSetOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v *BackendSet) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput)
}

// (Updatable) The load balancer policy for the backend set. To get a list of available policies, use the [ListPolicies](https://docs.cloud.oracle.com/iaas/api/#/en/loadbalancer/20170115/LoadBalancerPolicy/ListPolicies) operation.  Example: `LEAST_CONNECTIONS`
func (o BackendSetOutput) Policy() pulumi.StringOutput {
	return o.ApplyT(func(v *BackendSet) pulumi.StringOutput { return v.Policy }).(pulumi.StringOutput)
}

// (Updatable) The configuration details for implementing session persistence based on a user-specified cookie name (application cookie stickiness).
//
// Session persistence enables the Load Balancing service to direct any number of requests that originate from a single logical client to a single backend web server. For more information, see [Session Persistence](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/sessionpersistence.htm).
//
// With application cookie stickiness, the load balancer enables session persistence only when the response from a backend application server includes a `Set-cookie` header with the user-specified cookie name.
//
// To disable application cookie stickiness on a running load balancer, use the [UpdateBackendSet](https://docs.cloud.oracle.com/iaas/api/#/en/loadbalancer/20170115/BackendSet/UpdateBackendSet) operation and specify `null` for the `SessionPersistenceConfigurationDetails` object.
//
// Example: `SessionPersistenceConfigurationDetails: null`
//
// **Note:** `SessionPersistenceConfigurationDetails` (application cookie stickiness) and `LBCookieSessionPersistenceConfigurationDetails` (LB cookie stickiness) are mutually exclusive. An error results if you try to enable both types of session persistence.
//
// **Warning:** Oracle recommends that you avoid using any confidential information when you supply string values using the API.
func (o BackendSetOutput) SessionPersistenceConfiguration() BackendSetSessionPersistenceConfigurationOutput {
	return o.ApplyT(func(v *BackendSet) BackendSetSessionPersistenceConfigurationOutput {
		return v.SessionPersistenceConfiguration
	}).(BackendSetSessionPersistenceConfigurationOutput)
}

// (Updatable) The load balancer's SSL handling configuration details.
//
// **Warning:** Oracle recommends that you avoid using any confidential information when you supply string values using the API.
func (o BackendSetOutput) SslConfiguration() BackendSetSslConfigurationPtrOutput {
	return o.ApplyT(func(v *BackendSet) BackendSetSslConfigurationPtrOutput { return v.SslConfiguration }).(BackendSetSslConfigurationPtrOutput)
}

func (o BackendSetOutput) State() pulumi.StringOutput {
	return o.ApplyT(func(v *BackendSet) pulumi.StringOutput { return v.State }).(pulumi.StringOutput)
}

type BackendSetArrayOutput struct{ *pulumi.OutputState }

func (BackendSetArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]*BackendSet)(nil)).Elem()
}

func (o BackendSetArrayOutput) ToBackendSetArrayOutput() BackendSetArrayOutput {
	return o
}

func (o BackendSetArrayOutput) ToBackendSetArrayOutputWithContext(ctx context.Context) BackendSetArrayOutput {
	return o
}

func (o BackendSetArrayOutput) Index(i pulumi.IntInput) BackendSetOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *BackendSet {
		return vs[0].([]*BackendSet)[vs[1].(int)]
	}).(BackendSetOutput)
}

type BackendSetMapOutput struct{ *pulumi.OutputState }

func (BackendSetMapOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*map[string]*BackendSet)(nil)).Elem()
}

func (o BackendSetMapOutput) ToBackendSetMapOutput() BackendSetMapOutput {
	return o
}

func (o BackendSetMapOutput) ToBackendSetMapOutputWithContext(ctx context.Context) BackendSetMapOutput {
	return o
}

func (o BackendSetMapOutput) MapIndex(k pulumi.StringInput) BackendSetOutput {
	return pulumi.All(o, k).ApplyT(func(vs []interface{}) *BackendSet {
		return vs[0].(map[string]*BackendSet)[vs[1].(string)]
	}).(BackendSetOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*BackendSetInput)(nil)).Elem(), &BackendSet{})
	pulumi.RegisterInputType(reflect.TypeOf((*BackendSetArrayInput)(nil)).Elem(), BackendSetArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*BackendSetMapInput)(nil)).Elem(), BackendSetMap{})
	pulumi.RegisterOutputType(BackendSetOutput{})
	pulumi.RegisterOutputType(BackendSetArrayOutput{})
	pulumi.RegisterOutputType(BackendSetMapOutput{})
}