Docs Home Pulumi IaC Pulumi ESC Pulumi Cloud Packages Tutorials
  1. Packages
  2. Linode Provider
  3. API Docs
  4. getNodebalancerConfigs
Linode v4.30.0 published on Friday, Nov 8, 2024 by Pulumi
pulumi/pulumi-linode

linode.getNodebalancerConfigs

Explore with Pulumi AI

linode logo
Linode v4.30.0 published on Friday, Nov 8, 2024 by Pulumi
pulumi/pulumi-linode

    Provides information about Linode NodeBalancer Configs that match a set of filters. For more information, see the Linode APIv4 docs.

    Example Usage

    The following example shows how one might use this data source to access information about a list of NodeBalancer Configs.

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

const filterNbConfigs = linode.getNodebalancerConfigs({
    nodebalancerId: 12345,
    filters: [{
        name: "port",
        values: ["80"],
    }],
});
export const nodebalancerConfigId = filterNbConfigs.then(filterNbConfigs => filterNbConfigs.nodebalancerConfigs?.[0]?.id);

    import pulumi
import pulumi_linode as linode

filter_nb_configs = linode.get_nodebalancer_configs(nodebalancer_id=12345,
    filters=[{
        "name": "port",
        "values": ["80"],
    }])
pulumi.export("nodebalancerConfigId", filter_nb_configs.nodebalancer_configs[0].id)

    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 {
		filterNbConfigs, err := linode.GetNodebalancerConfigs(ctx, &linode.GetNodebalancerConfigsArgs{
			NodebalancerId: 12345,
			Filters: []linode.GetNodebalancerConfigsFilter{
				{
					Name: "port",
					Values: []string{
						"80",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("nodebalancerConfigId", filterNbConfigs.NodebalancerConfigs[0].Id)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var filterNbConfigs = Linode.GetNodebalancerConfigs.Invoke(new()
    {
        NodebalancerId = 12345,
        Filters = new[]
        {
            new Linode.Inputs.GetNodebalancerConfigsFilterInputArgs
            {
                Name = "port",
                Values = new[]
                {
                    "80",
                },
            },
        },
    });

    return new Dictionary<string, object?>
    {
        ["nodebalancerConfigId"] = filterNbConfigs.Apply(getNodebalancerConfigsResult => getNodebalancerConfigsResult.NodebalancerConfigs[0]?.Id),
    };
});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.linode.LinodeFunctions;
import com.pulumi.linode.inputs.GetNodebalancerConfigsArgs;
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) {
        final var filterNbConfigs = LinodeFunctions.getNodebalancerConfigs(GetNodebalancerConfigsArgs.builder()
            .nodebalancerId(12345)
            .filters(GetNodebalancerConfigsFilterArgs.builder()
                .name("port")
                .values("80")
                .build())
            .build());

        ctx.export("nodebalancerConfigId", filterNbConfigs.applyValue(getNodebalancerConfigsResult -> getNodebalancerConfigsResult.nodebalancerConfigs()[0].id()));
    }
}

    variables:
  filterNbConfigs:
    fn::invoke:
      Function: linode:getNodebalancerConfigs
      Arguments:
        nodebalancerId: 12345
        filters:
          - name: port
            values:
              - '80'
outputs:
  nodebalancerConfigId: ${filterNbConfigs.nodebalancerConfigs[0].id}

    Filterable Fields

    • algorithm

    • check

    • nodebalancer_id

    • port

    • protocol

    • proxy_protocol

    • stickiness

    • check_path

    • check_body

    • check_passive

    • cipher_suite

    • ssl_commonname

    Using getNodebalancerConfigs

    Two invocation forms are available. The direct form accepts plain arguments and either blocks until the result value is available, or returns a Promise-wrapped result. The output form accepts Input-wrapped arguments and returns an Output-wrapped result.

    function getNodebalancerConfigs(args: GetNodebalancerConfigsArgs, opts?: InvokeOptions): Promise<GetNodebalancerConfigsResult>
function getNodebalancerConfigsOutput(args: GetNodebalancerConfigsOutputArgs, opts?: InvokeOptions): Output<GetNodebalancerConfigsResult>
    def get_nodebalancer_configs(filters: Optional[Sequence[GetNodebalancerConfigsFilter]] = None,
                             nodebalancer_configs: Optional[Sequence[GetNodebalancerConfigsNodebalancerConfig]] = None,
                             nodebalancer_id: Optional[int] = None,
                             order: Optional[str] = None,
                             order_by: Optional[str] = None,
                             opts: Optional[InvokeOptions] = None) -> GetNodebalancerConfigsResult
def get_nodebalancer_configs_output(filters: Optional[pulumi.Input[Sequence[pulumi.Input[GetNodebalancerConfigsFilterArgs]]]] = None,
                             nodebalancer_configs: Optional[pulumi.Input[Sequence[pulumi.Input[GetNodebalancerConfigsNodebalancerConfigArgs]]]] = None,
                             nodebalancer_id: Optional[pulumi.Input[int]] = None,
                             order: Optional[pulumi.Input[str]] = None,
                             order_by: Optional[pulumi.Input[str]] = None,
                             opts: Optional[InvokeOptions] = None) -> Output[GetNodebalancerConfigsResult]
    func GetNodebalancerConfigs(ctx *Context, args *GetNodebalancerConfigsArgs, opts ...InvokeOption) (*GetNodebalancerConfigsResult, error)
func GetNodebalancerConfigsOutput(ctx *Context, args *GetNodebalancerConfigsOutputArgs, opts ...InvokeOption) GetNodebalancerConfigsResultOutput

    > Note: This function is named GetNodebalancerConfigs in the Go SDK.

    public static class GetNodebalancerConfigs 
{
    public static Task<GetNodebalancerConfigsResult> InvokeAsync(GetNodebalancerConfigsArgs args, InvokeOptions? opts = null)
    public static Output<GetNodebalancerConfigsResult> Invoke(GetNodebalancerConfigsInvokeArgs args, InvokeOptions? opts = null)
}
    public static CompletableFuture<GetNodebalancerConfigsResult> getNodebalancerConfigs(GetNodebalancerConfigsArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

    fn::invoke:
  function: linode:index/getNodebalancerConfigs:getNodebalancerConfigs
  arguments:
    # arguments dictionary

    The following arguments are supported:

    NodebalancerId int
    The ID of the NodeBalancer to access.

    • filter - (Optional) A set of filters used to select Linode NodeBalancers that meet certain requirements.
    Filters List<GetNodebalancerConfigsFilter>
    NodebalancerConfigs List<GetNodebalancerConfigsNodebalancerConfig>
    Order string
    The order in which results should be returned. (asc, desc; default asc)
    OrderBy string
    The attribute to order the results by. See the Filterable Fields section for a list of valid fields.
    NodebalancerId int
    The ID of the NodeBalancer to access.

    • filter - (Optional) A set of filters used to select Linode NodeBalancers that meet certain requirements.
    Filters []GetNodebalancerConfigsFilter
    NodebalancerConfigs []GetNodebalancerConfigsNodebalancerConfig
    Order string
    The order in which results should be returned. (asc, desc; default asc)
    OrderBy string
    The attribute to order the results by. See the Filterable Fields section for a list of valid fields.
    nodebalancerId Integer
    The ID of the NodeBalancer to access.

    • filter - (Optional) A set of filters used to select Linode NodeBalancers that meet certain requirements.
    filters List<GetNodebalancerConfigsFilter>
    nodebalancerConfigs List<GetNodebalancerConfigsNodebalancerConfig>
    order String
    The order in which results should be returned. (asc, desc; default asc)
    orderBy String
    The attribute to order the results by. See the Filterable Fields section for a list of valid fields.
    nodebalancerId number
    The ID of the NodeBalancer to access.

    • filter - (Optional) A set of filters used to select Linode NodeBalancers that meet certain requirements.
    filters GetNodebalancerConfigsFilter[]
    nodebalancerConfigs GetNodebalancerConfigsNodebalancerConfig[]
    order string
    The order in which results should be returned. (asc, desc; default asc)
    orderBy string
    The attribute to order the results by. See the Filterable Fields section for a list of valid fields.
    nodebalancer_id int
    The ID of the NodeBalancer to access.

    • filter - (Optional) A set of filters used to select Linode NodeBalancers that meet certain requirements.
    filters Sequence[GetNodebalancerConfigsFilter]
    nodebalancer_configs Sequence[GetNodebalancerConfigsNodebalancerConfig]
    order str
    The order in which results should be returned. (asc, desc; default asc)
    order_by str
    The attribute to order the results by. See the Filterable Fields section for a list of valid fields.
    nodebalancerId Number
    The ID of the NodeBalancer to access.

    • filter - (Optional) A set of filters used to select Linode NodeBalancers that meet certain requirements.
    filters List<Property Map>
    nodebalancerConfigs List<Property Map>
    order String
    The order in which results should be returned. (asc, desc; default asc)
    orderBy String
    The attribute to order the results by. See the Filterable Fields section for a list of valid fields.

    getNodebalancerConfigs Result

    The following output properties are available:

    Id string
    The config's ID.
    NodebalancerId int
    The ID of the NodeBalancer that contains the config.
    Filters List<GetNodebalancerConfigsFilter>
    NodebalancerConfigs List<GetNodebalancerConfigsNodebalancerConfig>
    Order string
    OrderBy string
    Id string
    The config's ID.
    NodebalancerId int
    The ID of the NodeBalancer that contains the config.
    Filters []GetNodebalancerConfigsFilter
    NodebalancerConfigs []GetNodebalancerConfigsNodebalancerConfig
    Order string
    OrderBy string
    id String
    The config's ID.
    nodebalancerId Integer
    The ID of the NodeBalancer that contains the config.
    filters List<GetNodebalancerConfigsFilter>
    nodebalancerConfigs List<GetNodebalancerConfigsNodebalancerConfig>
    order String
    orderBy String
    id string
    The config's ID.
    nodebalancerId number
    The ID of the NodeBalancer that contains the config.
    filters GetNodebalancerConfigsFilter[]
    nodebalancerConfigs GetNodebalancerConfigsNodebalancerConfig[]
    order string
    orderBy string
    id String
    The config's ID.
    nodebalancerId Number
    The ID of the NodeBalancer that contains the config.
    filters List<Property Map>
    nodebalancerConfigs List<Property Map>
    order String
    orderBy String

    Supporting Types

    GetNodebalancerConfigsFilter

    Name string
    The name of the field to filter by. See the Filterable Fields section for a complete list of filterable fields.
    Values List<string>
    A list of values for the filter to allow. These values should all be in string form.
    MatchBy string
    The method to match the field by. (exact, regex, substring; default exact)
    Name string
    The name of the field to filter by. See the Filterable Fields section for a complete list of filterable fields.
    Values []string
    A list of values for the filter to allow. These values should all be in string form.
    MatchBy string
    The method to match the field by. (exact, regex, substring; default exact)
    name String
    The name of the field to filter by. See the Filterable Fields section for a complete list of filterable fields.
    values List<String>
    A list of values for the filter to allow. These values should all be in string form.
    matchBy String
    The method to match the field by. (exact, regex, substring; default exact)
    name string
    The name of the field to filter by. See the Filterable Fields section for a complete list of filterable fields.
    values string[]
    A list of values for the filter to allow. These values should all be in string form.
    matchBy string
    The method to match the field by. (exact, regex, substring; default exact)
    name str
    The name of the field to filter by. See the Filterable Fields section for a complete list of filterable fields.
    values Sequence[str]
    A list of values for the filter to allow. These values should all be in string form.
    match_by str
    The method to match the field by. (exact, regex, substring; default exact)
    name String
    The name of the field to filter by. See the Filterable Fields section for a complete list of filterable fields.
    values List<String>
    A list of values for the filter to allow. These values should all be in string form.
    matchBy String
    The method to match the field by. (exact, regex, substring; default exact)

    GetNodebalancerConfigsNodebalancerConfig

    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. (recommended, legacy)
    Id int
    The config's ID.
    NodeStatuses List<GetNodebalancerConfigsNodebalancerConfigNodeStatus>
    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.

    • filter - (Optional) A set of filters used to select Linode NodeBalancers that meet certain requirements.
    Port int
    The TCP port this Config is for.
    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, and v2) (Defaults to none)
    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.
    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. (recommended, legacy)
    Id int
    The config's ID.
    NodeStatuses []GetNodebalancerConfigsNodebalancerConfigNodeStatus
    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.

    • filter - (Optional) A set of filters used to select Linode NodeBalancers that meet certain requirements.
    Port int
    The TCP port this Config is for.
    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, and v2) (Defaults to none)
    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.
    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. (recommended, legacy)
    id Integer
    The config's ID.
    nodeStatuses List<GetNodebalancerConfigsNodebalancerConfigNodeStatus>
    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.

    • filter - (Optional) A set of filters used to select Linode NodeBalancers that meet certain requirements.
    port Integer
    The TCP port this Config is for.
    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, and v2) (Defaults to none)
    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.
    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. (recommended, legacy)
    id number
    The config's ID.
    nodeStatuses GetNodebalancerConfigsNodebalancerConfigNodeStatus[]
    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.

    • filter - (Optional) A set of filters used to select Linode NodeBalancers that meet certain requirements.
    port number
    The TCP port this Config is for.
    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, and v2) (Defaults to none)
    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.
    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. (recommended, legacy)
    id int
    The config's ID.
    node_statuses Sequence[GetNodebalancerConfigsNodebalancerConfigNodeStatus]
    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.

    • filter - (Optional) A set of filters used to select Linode NodeBalancers that meet certain requirements.
    port int
    The TCP port this Config is for.
    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, and v2) (Defaults to none)
    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.
    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. (recommended, legacy)
    id Number
    The config's ID.
    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.

    • filter - (Optional) A set of filters used to select Linode NodeBalancers that meet certain requirements.
    port Number
    The TCP port this Config is for.
    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, and v2) (Defaults to none)
    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.
    stickiness String
    Controls how session stickiness is handled on this port. (none, table, http_cookie)

    GetNodebalancerConfigsNodebalancerConfigNodeStatus

    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.

    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.30.0 published on Friday, Nov 8, 2024 by Pulumi
    pulumi/pulumi-linode