pulumi-cloudflare-kotlin/com.pulumi.cloudflare.kotlin/LoadBalancerPoolArgs

LoadBalancerPoolArgs

data class LoadBalancerPoolArgs(val accountId: Output<String>? = null, val checkRegions: Output<List<String>>? = null, val description: Output<String>? = null, val enabled: Output<Boolean>? = null, val latitude: Output<Double>? = null, val loadSheddings: Output<List<LoadBalancerPoolLoadSheddingArgs>>? = null, val longitude: Output<Double>? = null, val minimumOrigins: Output<Int>? = null, val monitor: Output<String>? = null, val name: Output<String>? = null, val notificationEmail: Output<String>? = null, val originSteerings: Output<List<LoadBalancerPoolOriginSteeringArgs>>? = null, val origins: Output<List<LoadBalancerPoolOriginArgs>>? = null) : ConvertibleToJava<LoadBalancerPoolArgs>

Provides a Cloudflare Load Balancer pool resource. This provides a pool of origins that can be used by a Cloudflare Load Balancer.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as cloudflare from "@pulumi/cloudflare";
const example = new cloudflare.LoadBalancerPool("example", {
    accountId: "f037e56e89293a057740de681ac9abbe",
    name: "example-pool",
    origins: [
        {
            name: "example-1",
            address: "192.0.2.1",
            enabled: false,
            headers: [{
                header: "Host",
                values: ["example-1"],
            }],
        },
        {
            name: "example-2",
            address: "192.0.2.2",
            headers: [{
                header: "Host",
                values: ["example-2"],
            }],
        },
    ],
    latitude: 55,
    longitude: -12,
    description: "example load balancer pool",
    enabled: false,
    minimumOrigins: 1,
    notificationEmail: "someone@example.com",
    loadSheddings: [{
        defaultPercent: 55,
        defaultPolicy: "random",
        sessionPercent: 12,
        sessionPolicy: "hash",
    }],
    originSteerings: [{
        policy: "random",
    }],
});
Content copied to clipboard
import pulumi
import pulumi_cloudflare as cloudflare
example = cloudflare.LoadBalancerPool("example",
    account_id="f037e56e89293a057740de681ac9abbe",
    name="example-pool",
    origins=[
        {
            "name": "example-1",
            "address": "192.0.2.1",
            "enabled": False,
            "headers": [{
                "header": "Host",
                "values": ["example-1"],
            }],
        },
        {
            "name": "example-2",
            "address": "192.0.2.2",
            "headers": [{
                "header": "Host",
                "values": ["example-2"],
            }],
        },
    ],
    latitude=55,
    longitude=-12,
    description="example load balancer pool",
    enabled=False,
    minimum_origins=1,
    notification_email="someone@example.com",
    load_sheddings=[{
        "default_percent": 55,
        "default_policy": "random",
        "session_percent": 12,
        "session_policy": "hash",
    }],
    origin_steerings=[{
        "policy": "random",
    }])
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Cloudflare = Pulumi.Cloudflare;
return await Deployment.RunAsync(() =>
{
    var example = new Cloudflare.LoadBalancerPool("example", new()
    {
        AccountId = "f037e56e89293a057740de681ac9abbe",
        Name = "example-pool",
        Origins = new[]
        {
            new Cloudflare.Inputs.LoadBalancerPoolOriginArgs
            {
                Name = "example-1",
                Address = "192.0.2.1",
                Enabled = false,
                Headers = new[]
                {
                    new Cloudflare.Inputs.LoadBalancerPoolOriginHeaderArgs
                    {
                        Header = "Host",
                        Values = new[]
                        {
                            "example-1",
                        },
                    },
                },
            },
            new Cloudflare.Inputs.LoadBalancerPoolOriginArgs
            {
                Name = "example-2",
                Address = "192.0.2.2",
                Headers = new[]
                {
                    new Cloudflare.Inputs.LoadBalancerPoolOriginHeaderArgs
                    {
                        Header = "Host",
                        Values = new[]
                        {
                            "example-2",
                        },
                    },
                },
            },
        },
        Latitude = 55,
        Longitude = -12,
        Description = "example load balancer pool",
        Enabled = false,
        MinimumOrigins = 1,
        NotificationEmail = "someone@example.com",
        LoadSheddings = new[]
        {
            new Cloudflare.Inputs.LoadBalancerPoolLoadSheddingArgs
            {
                DefaultPercent = 55,
                DefaultPolicy = "random",
                SessionPercent = 12,
                SessionPolicy = "hash",
            },
        },
        OriginSteerings = new[]
        {
            new Cloudflare.Inputs.LoadBalancerPoolOriginSteeringArgs
            {
                Policy = "random",
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-cloudflare/sdk/v5/go/cloudflare"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloudflare.NewLoadBalancerPool(ctx, "example", &cloudflare.LoadBalancerPoolArgs{
			AccountId: pulumi.String("f037e56e89293a057740de681ac9abbe"),
			Name:      pulumi.String("example-pool"),
			Origins: cloudflare.LoadBalancerPoolOriginArray{
				&cloudflare.LoadBalancerPoolOriginArgs{
					Name:    pulumi.String("example-1"),
					Address: pulumi.String("192.0.2.1"),
					Enabled: pulumi.Bool(false),
					Headers: cloudflare.LoadBalancerPoolOriginHeaderArray{
						&cloudflare.LoadBalancerPoolOriginHeaderArgs{
							Header: pulumi.String("Host"),
							Values: pulumi.StringArray{
								pulumi.String("example-1"),
							},
						},
					},
				},
				&cloudflare.LoadBalancerPoolOriginArgs{
					Name:    pulumi.String("example-2"),
					Address: pulumi.String("192.0.2.2"),
					Headers: cloudflare.LoadBalancerPoolOriginHeaderArray{
						&cloudflare.LoadBalancerPoolOriginHeaderArgs{
							Header: pulumi.String("Host"),
							Values: pulumi.StringArray{
								pulumi.String("example-2"),
							},
						},
					},
				},
			},
			Latitude:          pulumi.Float64(55),
			Longitude:         pulumi.Float64(-12),
			Description:       pulumi.String("example load balancer pool"),
			Enabled:           pulumi.Bool(false),
			MinimumOrigins:    pulumi.Int(1),
			NotificationEmail: pulumi.String("someone@example.com"),
			LoadSheddings: cloudflare.LoadBalancerPoolLoadSheddingArray{
				&cloudflare.LoadBalancerPoolLoadSheddingArgs{
					DefaultPercent: pulumi.Float64(55),
					DefaultPolicy:  pulumi.String("random"),
					SessionPercent: pulumi.Float64(12),
					SessionPolicy:  pulumi.String("hash"),
				},
			},
			OriginSteerings: cloudflare.LoadBalancerPoolOriginSteeringArray{
				&cloudflare.LoadBalancerPoolOriginSteeringArgs{
					Policy: pulumi.String("random"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.cloudflare.LoadBalancerPool;
import com.pulumi.cloudflare.LoadBalancerPoolArgs;
import com.pulumi.cloudflare.inputs.LoadBalancerPoolOriginArgs;
import com.pulumi.cloudflare.inputs.LoadBalancerPoolLoadSheddingArgs;
import com.pulumi.cloudflare.inputs.LoadBalancerPoolOriginSteeringArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var example = new LoadBalancerPool("example", LoadBalancerPoolArgs.builder()
            .accountId("f037e56e89293a057740de681ac9abbe")
            .name("example-pool")
            .origins(
                LoadBalancerPoolOriginArgs.builder()
                    .name("example-1")
                    .address("192.0.2.1")
                    .enabled(false)
                    .headers(LoadBalancerPoolOriginHeaderArgs.builder()
                        .header("Host")
                        .values("example-1")
                        .build())
                    .build(),
                LoadBalancerPoolOriginArgs.builder()
                    .name("example-2")
                    .address("192.0.2.2")
                    .headers(LoadBalancerPoolOriginHeaderArgs.builder()
                        .header("Host")
                        .values("example-2")
                        .build())
                    .build())
            .latitude(55)
            .longitude(-12)
            .description("example load balancer pool")
            .enabled(false)
            .minimumOrigins(1)
            .notificationEmail("someone@example.com")
            .loadSheddings(LoadBalancerPoolLoadSheddingArgs.builder()
                .defaultPercent(55)
                .defaultPolicy("random")
                .sessionPercent(12)
                .sessionPolicy("hash")
                .build())
            .originSteerings(LoadBalancerPoolOriginSteeringArgs.builder()
                .policy("random")
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  example:
    type: cloudflare:LoadBalancerPool
    properties:
      accountId: f037e56e89293a057740de681ac9abbe
      name: example-pool
      origins:
        - name: example-1
          address: 192.0.2.1
          enabled: false
          headers:
            - header: Host
              values:
                - example-1
        - name: example-2
          address: 192.0.2.2
          headers:
            - header: Host
              values:
                - example-2
      latitude: 55
      longitude: -12
      description: example load balancer pool
      enabled: false
      minimumOrigins: 1
      notificationEmail: someone@example.com
      loadSheddings:
        - defaultPercent: 55
          defaultPolicy: random
          sessionPercent: 12
          sessionPolicy: hash
      originSteerings:
        - policy: random
Content copied to clipboard

Import

$ pulumi import cloudflare:index/loadBalancerPool:LoadBalancerPool example <account_id>/<load_balancer_pool_id>
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(accountId: Output<String>? = null, checkRegions: Output<List<String>>? = null, description: Output<String>? = null, enabled: Output<Boolean>? = null, latitude: Output<Double>? = null, loadSheddings: Output<List<LoadBalancerPoolLoadSheddingArgs>>? = null, longitude: Output<Double>? = null, minimumOrigins: Output<Int>? = null, monitor: Output<String>? = null, name: Output<String>? = null, notificationEmail: Output<String>? = null, originSteerings: Output<List<LoadBalancerPoolOriginSteeringArgs>>? = null, origins: Output<List<LoadBalancerPoolOriginArgs>>? = null)

Properties

Link copied to clipboard
val accountId: Output<String>? = null

The account identifier to target for the resource.

Link copied to clipboard
val checkRegions: Output<List<String>>? = null

A list of regions (specified by region code) from which to run health checks. Empty means every Cloudflare data center (the default), but requires an Enterprise plan. Region codes can be found here.

Link copied to clipboard
val description: Output<String>? = null

Free text description.

Link copied to clipboard
val enabled: Output<Boolean>? = null

Whether to enable (the default) this pool. Disabled pools will not receive traffic and are excluded from health checks. Disabling a pool will cause any load balancers using it to failover to the next pool (if any). Defaults to true.

Link copied to clipboard
val latitude: Output<Double>? = null

The latitude this pool is physically located at; used for proximity steering.

Link copied to clipboard
val loadSheddings: Output<List<LoadBalancerPoolLoadSheddingArgs>>? = null

Setting for controlling load shedding for this pool.

Link copied to clipboard
val longitude: Output<Double>? = null

The longitude this pool is physically located at; used for proximity steering.

Link copied to clipboard
val minimumOrigins: Output<Int>? = null

The minimum number of origins that must be healthy for this pool to serve traffic. If the number of healthy origins falls below this number, the pool will be marked unhealthy and we will failover to the next available pool. Defaults to 1.

Link copied to clipboard
val monitor: Output<String>? = null

The ID of the Monitor to use for health checking origins within this pool.

Link copied to clipboard
val name: Output<String>? = null

A short name (tag) for the pool.

Link copied to clipboard
val notificationEmail: Output<String>? = null

The email address to send health status notifications to. This can be an individual mailbox or a mailing list. Multiple emails can be supplied as a comma delimited list.

Link copied to clipboard
val origins: Output<List<LoadBalancerPoolOriginArgs>>? = null

The list of origins within this pool. Traffic directed at this pool is balanced across all currently healthy origins, provided the pool itself is healthy.

Link copied to clipboard
val originSteerings: Output<List<LoadBalancerPoolOriginSteeringArgs>>? = null

Set an origin steering policy to control origin selection within a pool.

Functions

Link copied to clipboard
open override fun toJava(): LoadBalancerPoolArgs