Docs Home Pulumi IaC Pulumi ESC Pulumi Insights Pulumi IDP Pulumi Cloud Packages Tutorials
  1. Packages
  2. Linode Provider
  3. API Docs
  4. NodeBalancerConfig
Linode v4.39.0 published on Thursday, May 8, 2025 by Pulumi
pulumi/pulumi-linode

linode.NodeBalancerConfig

Explore with Pulumi AI

linode logo
Linode v4.39.0 published on Thursday, May 8, 2025 by Pulumi
pulumi/pulumi-linode

    Provides a Linode NodeBalancer Config resource. This can be used to create, modify, and delete Linodes NodeBalancer Configs. For more information, see Getting Started with NodeBalancers and the Linode APIv4 docs.

    Example Usage

    The following example shows how one might use this resource to configure a NodeBalancer Config attached to a Linode instance.

    import * as pulumi from "@pulumi/pulumi";
import * as linode from "@pulumi/linode";

const foobar = new linode.NodeBalancer("foobar", {
    label: "mynodebalancer",
    region: "us-east",
    clientConnThrottle: 20,
});
const foofig = new linode.NodeBalancerConfig("foofig", {
    nodebalancerId: foobar.id,
    port: 8088,
    protocol: "http",
    check: "http",
    checkPath: "/foo",
    checkAttempts: 3,
    checkTimeout: 30,
    stickiness: "http_cookie",
    algorithm: "source",
});

    import pulumi
import pulumi_linode as linode

foobar = linode.NodeBalancer("foobar",
    label="mynodebalancer",
    region="us-east",
    client_conn_throttle=20)
foofig = linode.NodeBalancerConfig("foofig",
    nodebalancer_id=foobar.id,
    port=8088,
    protocol="http",
    check="http",
    check_path="/foo",
    check_attempts=3,
    check_timeout=30,
    stickiness="http_cookie",
    algorithm="source")

    package main

import (
	"github.com/pulumi/pulumi-linode/sdk/v4/go/linode"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		foobar, err := linode.NewNodeBalancer(ctx, "foobar", &linode.NodeBalancerArgs{
			Label:              pulumi.String("mynodebalancer"),
			Region:             pulumi.String("us-east"),
			ClientConnThrottle: pulumi.Int(20),
		})
		if err != nil {
			return err
		}
		_, err = linode.NewNodeBalancerConfig(ctx, "foofig", &linode.NodeBalancerConfigArgs{
			NodebalancerId: foobar.ID(),
			Port:           pulumi.Int(8088),
			Protocol:       pulumi.String("http"),
			Check:          pulumi.String("http"),
			CheckPath:      pulumi.String("/foo"),
			CheckAttempts:  pulumi.Int(3),
			CheckTimeout:   pulumi.Int(30),
			Stickiness:     pulumi.String("http_cookie"),
			Algorithm:      pulumi.String("source"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Linode = Pulumi.Linode;

return await Deployment.RunAsync(() => 
{
    var foobar = new Linode.NodeBalancer("foobar", new()
    {
        Label = "mynodebalancer",
        Region = "us-east",
        ClientConnThrottle = 20,
    });

    var foofig = new Linode.NodeBalancerConfig("foofig", new()
    {
        NodebalancerId = foobar.Id,
        Port = 8088,
        Protocol = "http",
        Check = "http",
        CheckPath = "/foo",
        CheckAttempts = 3,
        CheckTimeout = 30,
        Stickiness = "http_cookie",
        Algorithm = "source",
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.linode.NodeBalancer;
import com.pulumi.linode.NodeBalancerArgs;
import com.pulumi.linode.NodeBalancerConfig;
import com.pulumi.linode.NodeBalancerConfigArgs;
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 foobar = new NodeBalancer("foobar", NodeBalancerArgs.builder()
            .label("mynodebalancer")
            .region("us-east")
            .clientConnThrottle(20)
            .build());

        var foofig = new NodeBalancerConfig("foofig", NodeBalancerConfigArgs.builder()
            .nodebalancerId(foobar.id())
            .port(8088)
            .protocol("http")
            .check("http")
            .checkPath("/foo")
            .checkAttempts(3)
            .checkTimeout(30)
            .stickiness("http_cookie")
            .algorithm("source")
            .build());

    }
}

    resources:
  foobar:
    type: linode:NodeBalancer
    properties:
      label: mynodebalancer
      region: us-east
      clientConnThrottle: 20
  foofig:
    type: linode:NodeBalancerConfig
    properties:
      nodebalancerId: ${foobar.id}
      port: 8088
      protocol: http
      check: http
      checkPath: /foo
      checkAttempts: 3
      checkTimeout: 30
      stickiness: http_cookie
      algorithm: source

    Create NodeBalancerConfig Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new NodeBalancerConfig(name: string, args: NodeBalancerConfigArgs, opts?: CustomResourceOptions);
    @overload
def NodeBalancerConfig(resource_name: str,
                       args: NodeBalancerConfigArgs,
                       opts: Optional[ResourceOptions] = None)

@overload
def NodeBalancerConfig(resource_name: str,
                       opts: Optional[ResourceOptions] = None,
                       nodebalancer_id: Optional[int] = None,
                       cipher_suite: Optional[str] = None,
                       protocol: Optional[str] = None,
                       check_body: Optional[str] = None,
                       check_interval: Optional[int] = None,
                       check_passive: Optional[bool] = None,
                       check_path: Optional[str] = None,
                       check_attempts: Optional[int] = None,
                       check: Optional[str] = None,
                       check_timeout: Optional[int] = None,
                       port: Optional[int] = None,
                       algorithm: Optional[str] = None,
                       proxy_protocol: Optional[str] = None,
                       ssl_cert: Optional[str] = None,
                       ssl_key: Optional[str] = None,
                       stickiness: Optional[str] = None)
    func NewNodeBalancerConfig(ctx *Context, name string, args NodeBalancerConfigArgs, opts ...ResourceOption) (*NodeBalancerConfig, error)
    public NodeBalancerConfig(string name, NodeBalancerConfigArgs args, CustomResourceOptions? opts = null)
    public NodeBalancerConfig(String name, NodeBalancerConfigArgs args)
public NodeBalancerConfig(String name, NodeBalancerConfigArgs args, CustomResourceOptions options)

    type: linode:NodeBalancerConfig
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

    Parameters

    name string
    The unique name of the resource.
    args NodeBalancerConfigArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args NodeBalancerConfigArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args NodeBalancerConfigArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args NodeBalancerConfigArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args NodeBalancerConfigArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var nodeBalancerConfigResource = new Linode.NodeBalancerConfig("nodeBalancerConfigResource", new()
{
    NodebalancerId = 0,
    CipherSuite = "string",
    Protocol = "string",
    CheckBody = "string",
    CheckInterval = 0,
    CheckPassive = false,
    CheckPath = "string",
    CheckAttempts = 0,
    Check = "string",
    CheckTimeout = 0,
    Port = 0,
    Algorithm = "string",
    ProxyProtocol = "string",
    SslCert = "string",
    SslKey = "string",
    Stickiness = "string",
});

    example, err := linode.NewNodeBalancerConfig(ctx, "nodeBalancerConfigResource", &linode.NodeBalancerConfigArgs{
	NodebalancerId: pulumi.Int(0),
	CipherSuite:    pulumi.String("string"),
	Protocol:       pulumi.String("string"),
	CheckBody:      pulumi.String("string"),
	CheckInterval:  pulumi.Int(0),
	CheckPassive:   pulumi.Bool(false),
	CheckPath:      pulumi.String("string"),
	CheckAttempts:  pulumi.Int(0),
	Check:          pulumi.String("string"),
	CheckTimeout:   pulumi.Int(0),
	Port:           pulumi.Int(0),
	Algorithm:      pulumi.String("string"),
	ProxyProtocol:  pulumi.String("string"),
	SslCert:        pulumi.String("string"),
	SslKey:         pulumi.String("string"),
	Stickiness:     pulumi.String("string"),
})

    var nodeBalancerConfigResource = new NodeBalancerConfig("nodeBalancerConfigResource", NodeBalancerConfigArgs.builder()
    .nodebalancerId(0)
    .cipherSuite("string")
    .protocol("string")
    .checkBody("string")
    .checkInterval(0)
    .checkPassive(false)
    .checkPath("string")
    .checkAttempts(0)
    .check("string")
    .checkTimeout(0)
    .port(0)
    .algorithm("string")
    .proxyProtocol("string")
    .sslCert("string")
    .sslKey("string")
    .stickiness("string")
    .build());

    node_balancer_config_resource = linode.NodeBalancerConfig("nodeBalancerConfigResource",
    nodebalancer_id=0,
    cipher_suite="string",
    protocol="string",
    check_body="string",
    check_interval=0,
    check_passive=False,
    check_path="string",
    check_attempts=0,
    check="string",
    check_timeout=0,
    port=0,
    algorithm="string",
    proxy_protocol="string",
    ssl_cert="string",
    ssl_key="string",
    stickiness="string")

    const nodeBalancerConfigResource = new linode.NodeBalancerConfig("nodeBalancerConfigResource", {
    nodebalancerId: 0,
    cipherSuite: "string",
    protocol: "string",
    checkBody: "string",
    checkInterval: 0,
    checkPassive: false,
    checkPath: "string",
    checkAttempts: 0,
    check: "string",
    checkTimeout: 0,
    port: 0,
    algorithm: "string",
    proxyProtocol: "string",
    sslCert: "string",
    sslKey: "string",
    stickiness: "string",
});

    type: linode:NodeBalancerConfig
properties:
    algorithm: string
    check: string
    checkAttempts: 0
    checkBody: string
    checkInterval: 0
    checkPassive: false
    checkPath: string
    checkTimeout: 0
    cipherSuite: string
    nodebalancerId: 0
    port: 0
    protocol: string
    proxyProtocol: string
    sslCert: string
    sslKey: string
    stickiness: string

    NodeBalancerConfig Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The NodeBalancerConfig resource accepts the following input properties:

    NodebalancerId int
    The ID of the NodeBalancer to access.

    Algorithm string
    What algorithm this NodeBalancer should use for routing traffic to backends. (roundrobin, leastconn, source)
    Check string
    The type of check to perform against backends to ensure they are serving requests. This is used to determine if backends are up or down. If none no check is performed. connection requires only a connection to the backend to succeed. http and http_body rely on the backend serving HTTP, and that the response returned matches what is expected. (none, connection, http, http_body)
    CheckAttempts int
    How many times to attempt a check before considering a backend to be down. (1-30)
    CheckBody string
    This value must be present in the response body of the check in order for it to pass. If this value is not present in the response body of a check request, the backend is considered to be down
    CheckInterval int
    How often, in seconds, to check that backends are up and serving requests.
    CheckPassive bool
    If true, any response from this backend with a 5xx status code will be enough for it to be considered unhealthy and taken out of rotation.
    CheckPath string
    The URL path to check on each backend. If the backend does not respond to this request it is considered to be down.
    CheckTimeout int
    How long, in seconds, to wait for a check attempt before considering it failed. (1-30)
    CipherSuite string
    What ciphers to use for SSL connections served by this NodeBalancer. legacy is considered insecure and should only be used if necessary.
    Port int
    The TCP port this Config is for. These values must be unique across configs on a single NodeBalancer (you can't have two configs for port 80, for example). While some ports imply some protocols, no enforcement is done and you may configure your NodeBalancer however is useful to you. For example, while port 443 is generally used for HTTPS, you do not need SSL configured to have a NodeBalancer listening on port 443. (Defaults to 80)
    Protocol string
    The protocol this port is configured to serve. If this is set to https you must include an ssl_cert and an ssl_key. (http, https, tcp) (Defaults to http)
    ProxyProtocol string
    The version of ProxyProtocol to use for the underlying NodeBalancer. This requires protocol to be tcp. (none, v1, v2) (Defaults to none)
    SslCert string
    The certificate this port is serving. This is not returned. If set, this field will come back as <REDACTED>. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
    SslKey string
    The private key corresponding to this port's certificate. This is not returned. If set, this field will come back as <REDACTED>. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
    Stickiness string
    Controls how session stickiness is handled on this port. (none, table, http_cookie)
    NodebalancerId int
    The ID of the NodeBalancer to access.

    Algorithm string
    What algorithm this NodeBalancer should use for routing traffic to backends. (roundrobin, leastconn, source)
    Check string
    The type of check to perform against backends to ensure they are serving requests. This is used to determine if backends are up or down. If none no check is performed. connection requires only a connection to the backend to succeed. http and http_body rely on the backend serving HTTP, and that the response returned matches what is expected. (none, connection, http, http_body)
    CheckAttempts int
    How many times to attempt a check before considering a backend to be down. (1-30)
    CheckBody string
    This value must be present in the response body of the check in order for it to pass. If this value is not present in the response body of a check request, the backend is considered to be down
    CheckInterval int
    How often, in seconds, to check that backends are up and serving requests.
    CheckPassive bool
    If true, any response from this backend with a 5xx status code will be enough for it to be considered unhealthy and taken out of rotation.
    CheckPath string
    The URL path to check on each backend. If the backend does not respond to this request it is considered to be down.
    CheckTimeout int
    How long, in seconds, to wait for a check attempt before considering it failed. (1-30)
    CipherSuite string
    What ciphers to use for SSL connections served by this NodeBalancer. legacy is considered insecure and should only be used if necessary.
    Port int
    The TCP port this Config is for. These values must be unique across configs on a single NodeBalancer (you can't have two configs for port 80, for example). While some ports imply some protocols, no enforcement is done and you may configure your NodeBalancer however is useful to you. For example, while port 443 is generally used for HTTPS, you do not need SSL configured to have a NodeBalancer listening on port 443. (Defaults to 80)
    Protocol string
    The protocol this port is configured to serve. If this is set to https you must include an ssl_cert and an ssl_key. (http, https, tcp) (Defaults to http)
    ProxyProtocol string
    The version of ProxyProtocol to use for the underlying NodeBalancer. This requires protocol to be tcp. (none, v1, v2) (Defaults to none)
    SslCert string
    The certificate this port is serving. This is not returned. If set, this field will come back as <REDACTED>. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
    SslKey string
    The private key corresponding to this port's certificate. This is not returned. If set, this field will come back as <REDACTED>. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
    Stickiness string
    Controls how session stickiness is handled on this port. (none, table, http_cookie)
    nodebalancerId Integer
    The ID of the NodeBalancer to access.

    algorithm String
    What algorithm this NodeBalancer should use for routing traffic to backends. (roundrobin, leastconn, source)
    check String
    The type of check to perform against backends to ensure they are serving requests. This is used to determine if backends are up or down. If none no check is performed. connection requires only a connection to the backend to succeed. http and http_body rely on the backend serving HTTP, and that the response returned matches what is expected. (none, connection, http, http_body)
    checkAttempts Integer
    How many times to attempt a check before considering a backend to be down. (1-30)
    checkBody String
    This value must be present in the response body of the check in order for it to pass. If this value is not present in the response body of a check request, the backend is considered to be down
    checkInterval Integer
    How often, in seconds, to check that backends are up and serving requests.
    checkPassive Boolean
    If true, any response from this backend with a 5xx status code will be enough for it to be considered unhealthy and taken out of rotation.
    checkPath String
    The URL path to check on each backend. If the backend does not respond to this request it is considered to be down.
    checkTimeout Integer
    How long, in seconds, to wait for a check attempt before considering it failed. (1-30)
    cipherSuite String
    What ciphers to use for SSL connections served by this NodeBalancer. legacy is considered insecure and should only be used if necessary.
    port Integer
    The TCP port this Config is for. These values must be unique across configs on a single NodeBalancer (you can't have two configs for port 80, for example). While some ports imply some protocols, no enforcement is done and you may configure your NodeBalancer however is useful to you. For example, while port 443 is generally used for HTTPS, you do not need SSL configured to have a NodeBalancer listening on port 443. (Defaults to 80)
    protocol String
    The protocol this port is configured to serve. If this is set to https you must include an ssl_cert and an ssl_key. (http, https, tcp) (Defaults to http)
    proxyProtocol String
    The version of ProxyProtocol to use for the underlying NodeBalancer. This requires protocol to be tcp. (none, v1, v2) (Defaults to none)
    sslCert String
    The certificate this port is serving. This is not returned. If set, this field will come back as <REDACTED>. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
    sslKey String
    The private key corresponding to this port's certificate. This is not returned. If set, this field will come back as <REDACTED>. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
    stickiness String
    Controls how session stickiness is handled on this port. (none, table, http_cookie)
    nodebalancerId number
    The ID of the NodeBalancer to access.

    algorithm string
    What algorithm this NodeBalancer should use for routing traffic to backends. (roundrobin, leastconn, source)
    check string
    The type of check to perform against backends to ensure they are serving requests. This is used to determine if backends are up or down. If none no check is performed. connection requires only a connection to the backend to succeed. http and http_body rely on the backend serving HTTP, and that the response returned matches what is expected. (none, connection, http, http_body)
    checkAttempts number
    How many times to attempt a check before considering a backend to be down. (1-30)
    checkBody string
    This value must be present in the response body of the check in order for it to pass. If this value is not present in the response body of a check request, the backend is considered to be down
    checkInterval number
    How often, in seconds, to check that backends are up and serving requests.
    checkPassive boolean
    If true, any response from this backend with a 5xx status code will be enough for it to be considered unhealthy and taken out of rotation.
    checkPath string
    The URL path to check on each backend. If the backend does not respond to this request it is considered to be down.
    checkTimeout number
    How long, in seconds, to wait for a check attempt before considering it failed. (1-30)
    cipherSuite string
    What ciphers to use for SSL connections served by this NodeBalancer. legacy is considered insecure and should only be used if necessary.
    port number
    The TCP port this Config is for. These values must be unique across configs on a single NodeBalancer (you can't have two configs for port 80, for example). While some ports imply some protocols, no enforcement is done and you may configure your NodeBalancer however is useful to you. For example, while port 443 is generally used for HTTPS, you do not need SSL configured to have a NodeBalancer listening on port 443. (Defaults to 80)
    protocol string
    The protocol this port is configured to serve. If this is set to https you must include an ssl_cert and an ssl_key. (http, https, tcp) (Defaults to http)
    proxyProtocol string
    The version of ProxyProtocol to use for the underlying NodeBalancer. This requires protocol to be tcp. (none, v1, v2) (Defaults to none)
    sslCert string
    The certificate this port is serving. This is not returned. If set, this field will come back as <REDACTED>. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
    sslKey string
    The private key corresponding to this port's certificate. This is not returned. If set, this field will come back as <REDACTED>. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
    stickiness string
    Controls how session stickiness is handled on this port. (none, table, http_cookie)
    nodebalancer_id int
    The ID of the NodeBalancer to access.

    algorithm str
    What algorithm this NodeBalancer should use for routing traffic to backends. (roundrobin, leastconn, source)
    check str
    The type of check to perform against backends to ensure they are serving requests. This is used to determine if backends are up or down. If none no check is performed. connection requires only a connection to the backend to succeed. http and http_body rely on the backend serving HTTP, and that the response returned matches what is expected. (none, connection, http, http_body)
    check_attempts int
    How many times to attempt a check before considering a backend to be down. (1-30)
    check_body str
    This value must be present in the response body of the check in order for it to pass. If this value is not present in the response body of a check request, the backend is considered to be down
    check_interval int
    How often, in seconds, to check that backends are up and serving requests.
    check_passive bool
    If true, any response from this backend with a 5xx status code will be enough for it to be considered unhealthy and taken out of rotation.
    check_path str
    The URL path to check on each backend. If the backend does not respond to this request it is considered to be down.
    check_timeout int
    How long, in seconds, to wait for a check attempt before considering it failed. (1-30)
    cipher_suite str
    What ciphers to use for SSL connections served by this NodeBalancer. legacy is considered insecure and should only be used if necessary.
    port int
    The TCP port this Config is for. These values must be unique across configs on a single NodeBalancer (you can't have two configs for port 80, for example). While some ports imply some protocols, no enforcement is done and you may configure your NodeBalancer however is useful to you. For example, while port 443 is generally used for HTTPS, you do not need SSL configured to have a NodeBalancer listening on port 443. (Defaults to 80)
    protocol str
    The protocol this port is configured to serve. If this is set to https you must include an ssl_cert and an ssl_key. (http, https, tcp) (Defaults to http)
    proxy_protocol str
    The version of ProxyProtocol to use for the underlying NodeBalancer. This requires protocol to be tcp. (none, v1, v2) (Defaults to none)
    ssl_cert str
    The certificate this port is serving. This is not returned. If set, this field will come back as <REDACTED>. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
    ssl_key str
    The private key corresponding to this port's certificate. This is not returned. If set, this field will come back as <REDACTED>. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
    stickiness str
    Controls how session stickiness is handled on this port. (none, table, http_cookie)
    nodebalancerId Number
    The ID of the NodeBalancer to access.

    algorithm String
    What algorithm this NodeBalancer should use for routing traffic to backends. (roundrobin, leastconn, source)
    check String
    The type of check to perform against backends to ensure they are serving requests. This is used to determine if backends are up or down. If none no check is performed. connection requires only a connection to the backend to succeed. http and http_body rely on the backend serving HTTP, and that the response returned matches what is expected. (none, connection, http, http_body)
    checkAttempts Number
    How many times to attempt a check before considering a backend to be down. (1-30)
    checkBody String
    This value must be present in the response body of the check in order for it to pass. If this value is not present in the response body of a check request, the backend is considered to be down
    checkInterval Number
    How often, in seconds, to check that backends are up and serving requests.
    checkPassive Boolean
    If true, any response from this backend with a 5xx status code will be enough for it to be considered unhealthy and taken out of rotation.
    checkPath String
    The URL path to check on each backend. If the backend does not respond to this request it is considered to be down.
    checkTimeout Number
    How long, in seconds, to wait for a check attempt before considering it failed. (1-30)
    cipherSuite String
    What ciphers to use for SSL connections served by this NodeBalancer. legacy is considered insecure and should only be used if necessary.
    port Number
    The TCP port this Config is for. These values must be unique across configs on a single NodeBalancer (you can't have two configs for port 80, for example). While some ports imply some protocols, no enforcement is done and you may configure your NodeBalancer however is useful to you. For example, while port 443 is generally used for HTTPS, you do not need SSL configured to have a NodeBalancer listening on port 443. (Defaults to 80)
    protocol String
    The protocol this port is configured to serve. If this is set to https you must include an ssl_cert and an ssl_key. (http, https, tcp) (Defaults to http)
    proxyProtocol String
    The version of ProxyProtocol to use for the underlying NodeBalancer. This requires protocol to be tcp. (none, v1, v2) (Defaults to none)
    sslCert String
    The certificate this port is serving. This is not returned. If set, this field will come back as <REDACTED>. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
    sslKey String
    The private key corresponding to this port's certificate. This is not returned. If set, this field will come back as <REDACTED>. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
    stickiness String
    Controls how session stickiness is handled on this port. (none, table, http_cookie)

    Outputs

    All input properties are implicitly available as output properties. Additionally, the NodeBalancerConfig resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    NodeStatuses List<NodeBalancerConfigNodeStatus>
    A structure containing information about the health of the backends for this port. This information is updated periodically as checks are performed against backends.
    SslCommonname string
    The read-only common name automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
    SslFingerprint string
    The read-only fingerprint automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
    Id string
    The provider-assigned unique ID for this managed resource.
    NodeStatuses []NodeBalancerConfigNodeStatus
    A structure containing information about the health of the backends for this port. This information is updated periodically as checks are performed against backends.
    SslCommonname string
    The read-only common name automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
    SslFingerprint string
    The read-only fingerprint automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
    id String
    The provider-assigned unique ID for this managed resource.
    nodeStatuses List<NodeBalancerConfigNodeStatus>
    A structure containing information about the health of the backends for this port. This information is updated periodically as checks are performed against backends.
    sslCommonname String
    The read-only common name automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
    sslFingerprint String
    The read-only fingerprint automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
    id string
    The provider-assigned unique ID for this managed resource.
    nodeStatuses NodeBalancerConfigNodeStatus[]
    A structure containing information about the health of the backends for this port. This information is updated periodically as checks are performed against backends.
    sslCommonname string
    The read-only common name automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
    sslFingerprint string
    The read-only fingerprint automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
    id str
    The provider-assigned unique ID for this managed resource.
    node_statuses Sequence[NodeBalancerConfigNodeStatus]
    A structure containing information about the health of the backends for this port. This information is updated periodically as checks are performed against backends.
    ssl_commonname str
    The read-only common name automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
    ssl_fingerprint str
    The read-only fingerprint automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
    id String
    The provider-assigned unique ID for this managed resource.
    nodeStatuses List<Property Map>
    A structure containing information about the health of the backends for this port. This information is updated periodically as checks are performed against backends.
    sslCommonname String
    The read-only common name automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
    sslFingerprint String
    The read-only fingerprint automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.

    Look up Existing NodeBalancerConfig Resource

    Get an existing NodeBalancerConfig resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: NodeBalancerConfigState, opts?: CustomResourceOptions): NodeBalancerConfig
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        algorithm: Optional[str] = None,
        check: Optional[str] = None,
        check_attempts: Optional[int] = None,
        check_body: Optional[str] = None,
        check_interval: Optional[int] = None,
        check_passive: Optional[bool] = None,
        check_path: Optional[str] = None,
        check_timeout: Optional[int] = None,
        cipher_suite: Optional[str] = None,
        node_statuses: Optional[Sequence[NodeBalancerConfigNodeStatusArgs]] = None,
        nodebalancer_id: Optional[int] = None,
        port: Optional[int] = None,
        protocol: Optional[str] = None,
        proxy_protocol: Optional[str] = None,
        ssl_cert: Optional[str] = None,
        ssl_commonname: Optional[str] = None,
        ssl_fingerprint: Optional[str] = None,
        ssl_key: Optional[str] = None,
        stickiness: Optional[str] = None) -> NodeBalancerConfig
    func GetNodeBalancerConfig(ctx *Context, name string, id IDInput, state *NodeBalancerConfigState, opts ...ResourceOption) (*NodeBalancerConfig, error)
    public static NodeBalancerConfig Get(string name, Input<string> id, NodeBalancerConfigState? state, CustomResourceOptions? opts = null)
    public static NodeBalancerConfig get(String name, Output<String> id, NodeBalancerConfigState state, CustomResourceOptions options)
    resources:  _:    type: linode:NodeBalancerConfig    get:      id: ${id}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    Algorithm string
    What algorithm this NodeBalancer should use for routing traffic to backends. (roundrobin, leastconn, source)
    Check string
    The type of check to perform against backends to ensure they are serving requests. This is used to determine if backends are up or down. If none no check is performed. connection requires only a connection to the backend to succeed. http and http_body rely on the backend serving HTTP, and that the response returned matches what is expected. (none, connection, http, http_body)
    CheckAttempts int
    How many times to attempt a check before considering a backend to be down. (1-30)
    CheckBody string
    This value must be present in the response body of the check in order for it to pass. If this value is not present in the response body of a check request, the backend is considered to be down
    CheckInterval int
    How often, in seconds, to check that backends are up and serving requests.
    CheckPassive bool
    If true, any response from this backend with a 5xx status code will be enough for it to be considered unhealthy and taken out of rotation.
    CheckPath string
    The URL path to check on each backend. If the backend does not respond to this request it is considered to be down.
    CheckTimeout int
    How long, in seconds, to wait for a check attempt before considering it failed. (1-30)
    CipherSuite string
    What ciphers to use for SSL connections served by this NodeBalancer. legacy is considered insecure and should only be used if necessary.
    NodeStatuses List<NodeBalancerConfigNodeStatus>
    A structure containing information about the health of the backends for this port. This information is updated periodically as checks are performed against backends.
    NodebalancerId int
    The ID of the NodeBalancer to access.

    Port int
    The TCP port this Config is for. These values must be unique across configs on a single NodeBalancer (you can't have two configs for port 80, for example). While some ports imply some protocols, no enforcement is done and you may configure your NodeBalancer however is useful to you. For example, while port 443 is generally used for HTTPS, you do not need SSL configured to have a NodeBalancer listening on port 443. (Defaults to 80)
    Protocol string
    The protocol this port is configured to serve. If this is set to https you must include an ssl_cert and an ssl_key. (http, https, tcp) (Defaults to http)
    ProxyProtocol string
    The version of ProxyProtocol to use for the underlying NodeBalancer. This requires protocol to be tcp. (none, v1, v2) (Defaults to none)
    SslCert string
    The certificate this port is serving. This is not returned. If set, this field will come back as <REDACTED>. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
    SslCommonname string
    The read-only common name automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
    SslFingerprint string
    The read-only fingerprint automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
    SslKey string
    The private key corresponding to this port's certificate. This is not returned. If set, this field will come back as <REDACTED>. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
    Stickiness string
    Controls how session stickiness is handled on this port. (none, table, http_cookie)
    Algorithm string
    What algorithm this NodeBalancer should use for routing traffic to backends. (roundrobin, leastconn, source)
    Check string
    The type of check to perform against backends to ensure they are serving requests. This is used to determine if backends are up or down. If none no check is performed. connection requires only a connection to the backend to succeed. http and http_body rely on the backend serving HTTP, and that the response returned matches what is expected. (none, connection, http, http_body)
    CheckAttempts int
    How many times to attempt a check before considering a backend to be down. (1-30)
    CheckBody string
    This value must be present in the response body of the check in order for it to pass. If this value is not present in the response body of a check request, the backend is considered to be down
    CheckInterval int
    How often, in seconds, to check that backends are up and serving requests.
    CheckPassive bool
    If true, any response from this backend with a 5xx status code will be enough for it to be considered unhealthy and taken out of rotation.
    CheckPath string
    The URL path to check on each backend. If the backend does not respond to this request it is considered to be down.
    CheckTimeout int
    How long, in seconds, to wait for a check attempt before considering it failed. (1-30)
    CipherSuite string
    What ciphers to use for SSL connections served by this NodeBalancer. legacy is considered insecure and should only be used if necessary.
    NodeStatuses []NodeBalancerConfigNodeStatusArgs
    A structure containing information about the health of the backends for this port. This information is updated periodically as checks are performed against backends.
    NodebalancerId int
    The ID of the NodeBalancer to access.

    Port int
    The TCP port this Config is for. These values must be unique across configs on a single NodeBalancer (you can't have two configs for port 80, for example). While some ports imply some protocols, no enforcement is done and you may configure your NodeBalancer however is useful to you. For example, while port 443 is generally used for HTTPS, you do not need SSL configured to have a NodeBalancer listening on port 443. (Defaults to 80)
    Protocol string
    The protocol this port is configured to serve. If this is set to https you must include an ssl_cert and an ssl_key. (http, https, tcp) (Defaults to http)
    ProxyProtocol string
    The version of ProxyProtocol to use for the underlying NodeBalancer. This requires protocol to be tcp. (none, v1, v2) (Defaults to none)
    SslCert string
    The certificate this port is serving. This is not returned. If set, this field will come back as <REDACTED>. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
    SslCommonname string
    The read-only common name automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
    SslFingerprint string
    The read-only fingerprint automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
    SslKey string
    The private key corresponding to this port's certificate. This is not returned. If set, this field will come back as <REDACTED>. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
    Stickiness string
    Controls how session stickiness is handled on this port. (none, table, http_cookie)
    algorithm String
    What algorithm this NodeBalancer should use for routing traffic to backends. (roundrobin, leastconn, source)
    check String
    The type of check to perform against backends to ensure they are serving requests. This is used to determine if backends are up or down. If none no check is performed. connection requires only a connection to the backend to succeed. http and http_body rely on the backend serving HTTP, and that the response returned matches what is expected. (none, connection, http, http_body)
    checkAttempts Integer
    How many times to attempt a check before considering a backend to be down. (1-30)
    checkBody String
    This value must be present in the response body of the check in order for it to pass. If this value is not present in the response body of a check request, the backend is considered to be down
    checkInterval Integer
    How often, in seconds, to check that backends are up and serving requests.
    checkPassive Boolean
    If true, any response from this backend with a 5xx status code will be enough for it to be considered unhealthy and taken out of rotation.
    checkPath String
    The URL path to check on each backend. If the backend does not respond to this request it is considered to be down.
    checkTimeout Integer
    How long, in seconds, to wait for a check attempt before considering it failed. (1-30)
    cipherSuite String
    What ciphers to use for SSL connections served by this NodeBalancer. legacy is considered insecure and should only be used if necessary.
    nodeStatuses List<NodeBalancerConfigNodeStatus>
    A structure containing information about the health of the backends for this port. This information is updated periodically as checks are performed against backends.
    nodebalancerId Integer
    The ID of the NodeBalancer to access.

    port Integer
    The TCP port this Config is for. These values must be unique across configs on a single NodeBalancer (you can't have two configs for port 80, for example). While some ports imply some protocols, no enforcement is done and you may configure your NodeBalancer however is useful to you. For example, while port 443 is generally used for HTTPS, you do not need SSL configured to have a NodeBalancer listening on port 443. (Defaults to 80)
    protocol String
    The protocol this port is configured to serve. If this is set to https you must include an ssl_cert and an ssl_key. (http, https, tcp) (Defaults to http)
    proxyProtocol String
    The version of ProxyProtocol to use for the underlying NodeBalancer. This requires protocol to be tcp. (none, v1, v2) (Defaults to none)
    sslCert String
    The certificate this port is serving. This is not returned. If set, this field will come back as <REDACTED>. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
    sslCommonname String
    The read-only common name automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
    sslFingerprint String
    The read-only fingerprint automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
    sslKey String
    The private key corresponding to this port's certificate. This is not returned. If set, this field will come back as <REDACTED>. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
    stickiness String
    Controls how session stickiness is handled on this port. (none, table, http_cookie)
    algorithm string
    What algorithm this NodeBalancer should use for routing traffic to backends. (roundrobin, leastconn, source)
    check string
    The type of check to perform against backends to ensure they are serving requests. This is used to determine if backends are up or down. If none no check is performed. connection requires only a connection to the backend to succeed. http and http_body rely on the backend serving HTTP, and that the response returned matches what is expected. (none, connection, http, http_body)
    checkAttempts number
    How many times to attempt a check before considering a backend to be down. (1-30)
    checkBody string
    This value must be present in the response body of the check in order for it to pass. If this value is not present in the response body of a check request, the backend is considered to be down
    checkInterval number
    How often, in seconds, to check that backends are up and serving requests.
    checkPassive boolean
    If true, any response from this backend with a 5xx status code will be enough for it to be considered unhealthy and taken out of rotation.
    checkPath string
    The URL path to check on each backend. If the backend does not respond to this request it is considered to be down.
    checkTimeout number
    How long, in seconds, to wait for a check attempt before considering it failed. (1-30)
    cipherSuite string
    What ciphers to use for SSL connections served by this NodeBalancer. legacy is considered insecure and should only be used if necessary.
    nodeStatuses NodeBalancerConfigNodeStatus[]
    A structure containing information about the health of the backends for this port. This information is updated periodically as checks are performed against backends.
    nodebalancerId number
    The ID of the NodeBalancer to access.

    port number
    The TCP port this Config is for. These values must be unique across configs on a single NodeBalancer (you can't have two configs for port 80, for example). While some ports imply some protocols, no enforcement is done and you may configure your NodeBalancer however is useful to you. For example, while port 443 is generally used for HTTPS, you do not need SSL configured to have a NodeBalancer listening on port 443. (Defaults to 80)
    protocol string
    The protocol this port is configured to serve. If this is set to https you must include an ssl_cert and an ssl_key. (http, https, tcp) (Defaults to http)
    proxyProtocol string
    The version of ProxyProtocol to use for the underlying NodeBalancer. This requires protocol to be tcp. (none, v1, v2) (Defaults to none)
    sslCert string
    The certificate this port is serving. This is not returned. If set, this field will come back as <REDACTED>. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
    sslCommonname string
    The read-only common name automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
    sslFingerprint string
    The read-only fingerprint automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
    sslKey string
    The private key corresponding to this port's certificate. This is not returned. If set, this field will come back as <REDACTED>. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
    stickiness string
    Controls how session stickiness is handled on this port. (none, table, http_cookie)
    algorithm str
    What algorithm this NodeBalancer should use for routing traffic to backends. (roundrobin, leastconn, source)
    check str
    The type of check to perform against backends to ensure they are serving requests. This is used to determine if backends are up or down. If none no check is performed. connection requires only a connection to the backend to succeed. http and http_body rely on the backend serving HTTP, and that the response returned matches what is expected. (none, connection, http, http_body)
    check_attempts int
    How many times to attempt a check before considering a backend to be down. (1-30)
    check_body str
    This value must be present in the response body of the check in order for it to pass. If this value is not present in the response body of a check request, the backend is considered to be down
    check_interval int
    How often, in seconds, to check that backends are up and serving requests.
    check_passive bool
    If true, any response from this backend with a 5xx status code will be enough for it to be considered unhealthy and taken out of rotation.
    check_path str
    The URL path to check on each backend. If the backend does not respond to this request it is considered to be down.
    check_timeout int
    How long, in seconds, to wait for a check attempt before considering it failed. (1-30)
    cipher_suite str
    What ciphers to use for SSL connections served by this NodeBalancer. legacy is considered insecure and should only be used if necessary.
    node_statuses Sequence[NodeBalancerConfigNodeStatusArgs]
    A structure containing information about the health of the backends for this port. This information is updated periodically as checks are performed against backends.
    nodebalancer_id int
    The ID of the NodeBalancer to access.

    port int
    The TCP port this Config is for. These values must be unique across configs on a single NodeBalancer (you can't have two configs for port 80, for example). While some ports imply some protocols, no enforcement is done and you may configure your NodeBalancer however is useful to you. For example, while port 443 is generally used for HTTPS, you do not need SSL configured to have a NodeBalancer listening on port 443. (Defaults to 80)
    protocol str
    The protocol this port is configured to serve. If this is set to https you must include an ssl_cert and an ssl_key. (http, https, tcp) (Defaults to http)
    proxy_protocol str
    The version of ProxyProtocol to use for the underlying NodeBalancer. This requires protocol to be tcp. (none, v1, v2) (Defaults to none)
    ssl_cert str
    The certificate this port is serving. This is not returned. If set, this field will come back as <REDACTED>. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
    ssl_commonname str
    The read-only common name automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
    ssl_fingerprint str
    The read-only fingerprint automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
    ssl_key str
    The private key corresponding to this port's certificate. This is not returned. If set, this field will come back as <REDACTED>. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
    stickiness str
    Controls how session stickiness is handled on this port. (none, table, http_cookie)
    algorithm String
    What algorithm this NodeBalancer should use for routing traffic to backends. (roundrobin, leastconn, source)
    check String
    The type of check to perform against backends to ensure they are serving requests. This is used to determine if backends are up or down. If none no check is performed. connection requires only a connection to the backend to succeed. http and http_body rely on the backend serving HTTP, and that the response returned matches what is expected. (none, connection, http, http_body)
    checkAttempts Number
    How many times to attempt a check before considering a backend to be down. (1-30)
    checkBody String
    This value must be present in the response body of the check in order for it to pass. If this value is not present in the response body of a check request, the backend is considered to be down
    checkInterval Number
    How often, in seconds, to check that backends are up and serving requests.
    checkPassive Boolean
    If true, any response from this backend with a 5xx status code will be enough for it to be considered unhealthy and taken out of rotation.
    checkPath String
    The URL path to check on each backend. If the backend does not respond to this request it is considered to be down.
    checkTimeout Number
    How long, in seconds, to wait for a check attempt before considering it failed. (1-30)
    cipherSuite String
    What ciphers to use for SSL connections served by this NodeBalancer. legacy is considered insecure and should only be used if necessary.
    nodeStatuses List<Property Map>
    A structure containing information about the health of the backends for this port. This information is updated periodically as checks are performed against backends.
    nodebalancerId Number
    The ID of the NodeBalancer to access.

    port Number
    The TCP port this Config is for. These values must be unique across configs on a single NodeBalancer (you can't have two configs for port 80, for example). While some ports imply some protocols, no enforcement is done and you may configure your NodeBalancer however is useful to you. For example, while port 443 is generally used for HTTPS, you do not need SSL configured to have a NodeBalancer listening on port 443. (Defaults to 80)
    protocol String
    The protocol this port is configured to serve. If this is set to https you must include an ssl_cert and an ssl_key. (http, https, tcp) (Defaults to http)
    proxyProtocol String
    The version of ProxyProtocol to use for the underlying NodeBalancer. This requires protocol to be tcp. (none, v1, v2) (Defaults to none)
    sslCert String
    The certificate this port is serving. This is not returned. If set, this field will come back as <REDACTED>. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
    sslCommonname String
    The read-only common name automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
    sslFingerprint String
    The read-only fingerprint automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
    sslKey String
    The private key corresponding to this port's certificate. This is not returned. If set, this field will come back as <REDACTED>. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
    stickiness String
    Controls how session stickiness is handled on this port. (none, table, http_cookie)

    Supporting Types

    NodeBalancerConfigNodeStatus, NodeBalancerConfigNodeStatusArgs

    Down int
    The number of backends considered to be 'DOWN' and unhealthy. These are not in rotation, and not serving requests.
    Up int
    The number of backends considered to be 'UP' and healthy, and that are serving requests.
    Down int
    The number of backends considered to be 'DOWN' and unhealthy. These are not in rotation, and not serving requests.
    Up int
    The number of backends considered to be 'UP' and healthy, and that are serving requests.
    down Integer
    The number of backends considered to be 'DOWN' and unhealthy. These are not in rotation, and not serving requests.
    up Integer
    The number of backends considered to be 'UP' and healthy, and that are serving requests.
    down number
    The number of backends considered to be 'DOWN' and unhealthy. These are not in rotation, and not serving requests.
    up number
    The number of backends considered to be 'UP' and healthy, and that are serving requests.
    down int
    The number of backends considered to be 'DOWN' and unhealthy. These are not in rotation, and not serving requests.
    up int
    The number of backends considered to be 'UP' and healthy, and that are serving requests.
    down Number
    The number of backends considered to be 'DOWN' and unhealthy. These are not in rotation, and not serving requests.
    up Number
    The number of backends considered to be 'UP' and healthy, and that are serving requests.

    Import

    NodeBalancer Configs can be imported using the NodeBalancer nodebalancer_id followed by the NodeBalancer Config id separated by a comma, e.g.

    $ pulumi import linode:index/nodeBalancerConfig:NodeBalancerConfig http-foobar 1234567,7654321

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    Linode pulumi/pulumi-linode
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the linode Terraform Provider.
    linode logo
    Linode v4.39.0 published on Thursday, May 8, 2025 by Pulumi
    pulumi/pulumi-linode