import * as pulumi from "@pulumi/pulumi"; import * as inputs from "./types/input"; import * as outputs from "./types/output"; /** * ## Example Usage * * ## Import * * ```sh * $ pulumi import cloudflare:index/loadBalancer:LoadBalancer example '/' * ``` */ export declare class LoadBalancer extends pulumi.CustomResource { /** * Get an existing LoadBalancer resource's state with the given name, ID, and optional extra * properties used to qualify the lookup. * * @param name The _unique_ name of the resulting resource. * @param id The _unique_ provider ID of the resource to lookup. * @param state Any extra arguments used during the lookup. * @param opts Optional settings to control the behavior of the CustomResource. */ static get(name: string, id: pulumi.Input, state?: LoadBalancerState, opts?: pulumi.CustomResourceOptions): LoadBalancer; /** * Returns true if the given object is an instance of LoadBalancer. This is designed to work even * when multiple copies of the Pulumi SDK have been loaded into the same process. */ static isInstance(obj: any): obj is LoadBalancer; /** * Controls features that modify the routing of requests to pools and origins in response to dynamic conditions, such as during the interval between active health monitoring requests. For example, zero-downtime failover occurs immediately when an origin becomes unavailable due to HTTP 521, 522, or 523 response codes. If there is another healthy origin in the same pool, the request is retried once against this alternate origin. */ readonly adaptiveRouting: pulumi.Output; /** * A mapping of country codes to a list of pool IDs (ordered by their failover priority) for the given country. Any country not explicitly defined will fall back to using the corresponding region*pool mapping if it exists else to default*pools. */ readonly countryPools: pulumi.Output<{ [key: string]: string[]; }>; readonly createdOn: pulumi.Output; /** * A list of pool IDs ordered by their failover priority. Pools defined here are used by default, or when regionPools are not configured for a given region. */ readonly defaultPools: pulumi.Output; /** * Object description. */ readonly description: pulumi.Output; /** * Whether to enable (the default) this load balancer. */ readonly enabled: pulumi.Output; /** * The pool ID to use when all other pools are detected as unhealthy. */ readonly fallbackPool: pulumi.Output; /** * Controls location-based steering for non-proxied requests. See `steeringPolicy` to learn how steering is affected. */ readonly locationStrategy: pulumi.Output; readonly modifiedOn: pulumi.Output; /** * The DNS hostname to associate with your Load Balancer. If this hostname already exists as a DNS record in Cloudflare's DNS, the Load Balancer will take precedence and the DNS record will not be used. */ readonly name: pulumi.Output; /** * List of networks where Load Balancer or Pool is enabled. */ readonly networks: pulumi.Output; /** * Enterprise only: A mapping of Cloudflare PoP identifiers to a list of pool IDs (ordered by their failover priority) for the PoP (datacenter). Any PoPs not explicitly defined will fall back to using the corresponding country*pool, then region*pool mapping if it exists else to default_pools. */ readonly popPools: pulumi.Output<{ [key: string]: string[]; }>; /** * Whether the hostname should be gray clouded (false) or orange clouded (true). */ readonly proxied: pulumi.Output; /** * Configures pool weights. */ readonly randomSteering: pulumi.Output; /** * A mapping of region codes to a list of pool IDs (ordered by their failover priority) for the given region. Any regions not explicitly defined will fall back to using default_pools. */ readonly regionPools: pulumi.Output<{ [key: string]: string[]; }>; /** * BETA Field Not General Access: A list of rules for this load balancer to execute. */ readonly rules: pulumi.Output; /** * Specifies the type of session affinity the load balancer should use unless specified as `"none"`. The supported types are: - `"cookie"`: On the first request to a proxied load balancer, a cookie is generated, encoding information of which origin the request will be forwarded to. Subsequent requests, by the same client to the same load balancer, will be sent to the origin server the cookie encodes, for the duration of the cookie and as long as the origin server remains healthy. If the cookie has expired or the origin server is unhealthy, then a new origin server is calculated and used. - `"ipCookie"`: Behaves the same as `"cookie"` except the initial origin selection is stable and based on the client's ip address. - `"header"`: On the first request to a proxied load balancer, a session key based on the configured HTTP headers (see `session_affinity_attributes.headers`) is generated, encoding the request headers used for storing in the load balancer session state which origin the request will be forwarded to. Subsequent requests to the load balancer with the same headers will be sent to the same origin server, for the duration of the session and as long as the origin server remains healthy. If the session has been idle for the duration of `sessionAffinityTtl` seconds or the origin server is unhealthy, then a new origin server is calculated and used. See `headers` in `sessionAffinityAttributes` for additional required configuration. * Available values: "none", "cookie", "ipCookie", "header". */ readonly sessionAffinity: pulumi.Output; /** * Configures attributes for session affinity. */ readonly sessionAffinityAttributes: pulumi.Output; /** * Time, in seconds, until a client's session expires after being created. Once the expiry time has been reached, subsequent requests may get sent to a different origin server. The accepted ranges per `sessionAffinity` policy are: - `"cookie"` / `"ipCookie"`: The current default of 23 hours will be used unless explicitly set. The accepted range of values is between [1800, 604800]. - `"header"`: The current default of 1800 seconds will be used unless explicitly set. The accepted range of values is between [30, 3600]. Note: With session affinity by header, sessions only expire after they haven't been used for the number of seconds specified. */ readonly sessionAffinityTtl: pulumi.Output; /** * Steering Policy for this load balancer. */ readonly steeringPolicy: pulumi.Output; /** * Time to live (TTL) of the DNS entry for the IP address returned by this load balancer. This only applies to gray-clouded (unproxied) load balancers. */ readonly ttl: pulumi.Output; readonly zoneId: pulumi.Output; readonly zoneName: pulumi.Output; /** * Create a LoadBalancer resource with the given unique name, arguments, and options. * * @param name The _unique_ name of the resource. * @param args The arguments to use to populate this resource's properties. * @param opts A bag of options that control this resource's behavior. */ constructor(name: string, args: LoadBalancerArgs, opts?: pulumi.CustomResourceOptions); } /** * Input properties used for looking up and filtering LoadBalancer resources. */ export interface LoadBalancerState { /** * Controls features that modify the routing of requests to pools and origins in response to dynamic conditions, such as during the interval between active health monitoring requests. For example, zero-downtime failover occurs immediately when an origin becomes unavailable due to HTTP 521, 522, or 523 response codes. If there is another healthy origin in the same pool, the request is retried once against this alternate origin. */ adaptiveRouting?: pulumi.Input; /** * A mapping of country codes to a list of pool IDs (ordered by their failover priority) for the given country. Any country not explicitly defined will fall back to using the corresponding region*pool mapping if it exists else to default*pools. */ countryPools?: pulumi.Input<{ [key: string]: pulumi.Input[]>; }>; createdOn?: pulumi.Input; /** * A list of pool IDs ordered by their failover priority. Pools defined here are used by default, or when regionPools are not configured for a given region. */ defaultPools?: pulumi.Input[]>; /** * Object description. */ description?: pulumi.Input; /** * Whether to enable (the default) this load balancer. */ enabled?: pulumi.Input; /** * The pool ID to use when all other pools are detected as unhealthy. */ fallbackPool?: pulumi.Input; /** * Controls location-based steering for non-proxied requests. See `steeringPolicy` to learn how steering is affected. */ locationStrategy?: pulumi.Input; modifiedOn?: pulumi.Input; /** * The DNS hostname to associate with your Load Balancer. If this hostname already exists as a DNS record in Cloudflare's DNS, the Load Balancer will take precedence and the DNS record will not be used. */ name?: pulumi.Input; /** * List of networks where Load Balancer or Pool is enabled. */ networks?: pulumi.Input[]>; /** * Enterprise only: A mapping of Cloudflare PoP identifiers to a list of pool IDs (ordered by their failover priority) for the PoP (datacenter). Any PoPs not explicitly defined will fall back to using the corresponding country*pool, then region*pool mapping if it exists else to default_pools. */ popPools?: pulumi.Input<{ [key: string]: pulumi.Input[]>; }>; /** * Whether the hostname should be gray clouded (false) or orange clouded (true). */ proxied?: pulumi.Input; /** * Configures pool weights. */ randomSteering?: pulumi.Input; /** * A mapping of region codes to a list of pool IDs (ordered by their failover priority) for the given region. Any regions not explicitly defined will fall back to using default_pools. */ regionPools?: pulumi.Input<{ [key: string]: pulumi.Input[]>; }>; /** * BETA Field Not General Access: A list of rules for this load balancer to execute. */ rules?: pulumi.Input[]>; /** * Specifies the type of session affinity the load balancer should use unless specified as `"none"`. The supported types are: - `"cookie"`: On the first request to a proxied load balancer, a cookie is generated, encoding information of which origin the request will be forwarded to. Subsequent requests, by the same client to the same load balancer, will be sent to the origin server the cookie encodes, for the duration of the cookie and as long as the origin server remains healthy. If the cookie has expired or the origin server is unhealthy, then a new origin server is calculated and used. - `"ipCookie"`: Behaves the same as `"cookie"` except the initial origin selection is stable and based on the client's ip address. - `"header"`: On the first request to a proxied load balancer, a session key based on the configured HTTP headers (see `session_affinity_attributes.headers`) is generated, encoding the request headers used for storing in the load balancer session state which origin the request will be forwarded to. Subsequent requests to the load balancer with the same headers will be sent to the same origin server, for the duration of the session and as long as the origin server remains healthy. If the session has been idle for the duration of `sessionAffinityTtl` seconds or the origin server is unhealthy, then a new origin server is calculated and used. See `headers` in `sessionAffinityAttributes` for additional required configuration. * Available values: "none", "cookie", "ipCookie", "header". */ sessionAffinity?: pulumi.Input; /** * Configures attributes for session affinity. */ sessionAffinityAttributes?: pulumi.Input; /** * Time, in seconds, until a client's session expires after being created. Once the expiry time has been reached, subsequent requests may get sent to a different origin server. The accepted ranges per `sessionAffinity` policy are: - `"cookie"` / `"ipCookie"`: The current default of 23 hours will be used unless explicitly set. The accepted range of values is between [1800, 604800]. - `"header"`: The current default of 1800 seconds will be used unless explicitly set. The accepted range of values is between [30, 3600]. Note: With session affinity by header, sessions only expire after they haven't been used for the number of seconds specified. */ sessionAffinityTtl?: pulumi.Input; /** * Steering Policy for this load balancer. */ steeringPolicy?: pulumi.Input; /** * Time to live (TTL) of the DNS entry for the IP address returned by this load balancer. This only applies to gray-clouded (unproxied) load balancers. */ ttl?: pulumi.Input; zoneId?: pulumi.Input; zoneName?: pulumi.Input; } /** * The set of arguments for constructing a LoadBalancer resource. */ export interface LoadBalancerArgs { /** * Controls features that modify the routing of requests to pools and origins in response to dynamic conditions, such as during the interval between active health monitoring requests. For example, zero-downtime failover occurs immediately when an origin becomes unavailable due to HTTP 521, 522, or 523 response codes. If there is another healthy origin in the same pool, the request is retried once against this alternate origin. */ adaptiveRouting?: pulumi.Input; /** * A mapping of country codes to a list of pool IDs (ordered by their failover priority) for the given country. Any country not explicitly defined will fall back to using the corresponding region*pool mapping if it exists else to default*pools. */ countryPools?: pulumi.Input<{ [key: string]: pulumi.Input[]>; }>; /** * A list of pool IDs ordered by their failover priority. Pools defined here are used by default, or when regionPools are not configured for a given region. */ defaultPools: pulumi.Input[]>; /** * Object description. */ description?: pulumi.Input; /** * Whether to enable (the default) this load balancer. */ enabled?: pulumi.Input; /** * The pool ID to use when all other pools are detected as unhealthy. */ fallbackPool: pulumi.Input; /** * Controls location-based steering for non-proxied requests. See `steeringPolicy` to learn how steering is affected. */ locationStrategy?: pulumi.Input; /** * The DNS hostname to associate with your Load Balancer. If this hostname already exists as a DNS record in Cloudflare's DNS, the Load Balancer will take precedence and the DNS record will not be used. */ name: pulumi.Input; /** * List of networks where Load Balancer or Pool is enabled. */ networks?: pulumi.Input[]>; /** * Enterprise only: A mapping of Cloudflare PoP identifiers to a list of pool IDs (ordered by their failover priority) for the PoP (datacenter). Any PoPs not explicitly defined will fall back to using the corresponding country*pool, then region*pool mapping if it exists else to default_pools. */ popPools?: pulumi.Input<{ [key: string]: pulumi.Input[]>; }>; /** * Whether the hostname should be gray clouded (false) or orange clouded (true). */ proxied?: pulumi.Input; /** * Configures pool weights. */ randomSteering?: pulumi.Input; /** * A mapping of region codes to a list of pool IDs (ordered by their failover priority) for the given region. Any regions not explicitly defined will fall back to using default_pools. */ regionPools?: pulumi.Input<{ [key: string]: pulumi.Input[]>; }>; /** * BETA Field Not General Access: A list of rules for this load balancer to execute. */ rules?: pulumi.Input[]>; /** * Specifies the type of session affinity the load balancer should use unless specified as `"none"`. The supported types are: - `"cookie"`: On the first request to a proxied load balancer, a cookie is generated, encoding information of which origin the request will be forwarded to. Subsequent requests, by the same client to the same load balancer, will be sent to the origin server the cookie encodes, for the duration of the cookie and as long as the origin server remains healthy. If the cookie has expired or the origin server is unhealthy, then a new origin server is calculated and used. - `"ipCookie"`: Behaves the same as `"cookie"` except the initial origin selection is stable and based on the client's ip address. - `"header"`: On the first request to a proxied load balancer, a session key based on the configured HTTP headers (see `session_affinity_attributes.headers`) is generated, encoding the request headers used for storing in the load balancer session state which origin the request will be forwarded to. Subsequent requests to the load balancer with the same headers will be sent to the same origin server, for the duration of the session and as long as the origin server remains healthy. If the session has been idle for the duration of `sessionAffinityTtl` seconds or the origin server is unhealthy, then a new origin server is calculated and used. See `headers` in `sessionAffinityAttributes` for additional required configuration. * Available values: "none", "cookie", "ipCookie", "header". */ sessionAffinity?: pulumi.Input; /** * Configures attributes for session affinity. */ sessionAffinityAttributes?: pulumi.Input; /** * Time, in seconds, until a client's session expires after being created. Once the expiry time has been reached, subsequent requests may get sent to a different origin server. The accepted ranges per `sessionAffinity` policy are: - `"cookie"` / `"ipCookie"`: The current default of 23 hours will be used unless explicitly set. The accepted range of values is between [1800, 604800]. - `"header"`: The current default of 1800 seconds will be used unless explicitly set. The accepted range of values is between [30, 3600]. Note: With session affinity by header, sessions only expire after they haven't been used for the number of seconds specified. */ sessionAffinityTtl?: pulumi.Input; /** * Steering Policy for this load balancer. */ steeringPolicy?: pulumi.Input; /** * Time to live (TTL) of the DNS entry for the IP address returned by this load balancer. This only applies to gray-clouded (unproxied) load balancers. */ ttl?: pulumi.Input; zoneId: pulumi.Input; }