Docs Home Pulumi IaC Pulumi ESC Pulumi Cloud Packages Tutorials
  1. Packages
  2. Outscale Provider
  3. API Docs
  4. LoadBalancerListenerRule
outscale 1.0.1 published on Thursday, Mar 13, 2025 by outscale
outscale/terraform-provider-outscale

outscale.LoadBalancerListenerRule

Explore with Pulumi AI

outscale logo
outscale 1.0.1 published on Thursday, Mar 13, 2025 by outscale
outscale/terraform-provider-outscale

    Manages a load balancer listener rule.

    For more information on this resource, see the User Guide.
    For more information on this resource actions, see the API documentation.

    Example Usage

    Required resources

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

const vm01 = new outscale.Vm("vm01", {
    imageId: _var.image_id,
    vmType: _var.vm_type,
    keypairName: _var.keypair_name,
});
const loadBalancer01 = new outscale.LoadBalancer("loadBalancer01", {
    loadBalancerName: "terraform-public-load-balancer",
    subregionNames: [`${_var.region}a`],
    listeners: [{
        backendPort: 80,
        backendProtocol: "TCP",
        loadBalancerProtocol: "TCP",
        loadBalancerPort: 80,
    }],
    tags: [{
        key: "name",
        value: "terraform-public-load-balancer",
    }],
});
const outscaleLoadBalancerVms01 = new outscale.LoadBalancerVms("outscaleLoadBalancerVms01", {
    loadBalancerName: loadBalancer01.loadBalancerId,
    backendVmIds: [vm01.vmId],
});

    import pulumi
import pulumi_outscale as outscale

vm01 = outscale.Vm("vm01",
    image_id=var["image_id"],
    vm_type=var["vm_type"],
    keypair_name=var["keypair_name"])
load_balancer01 = outscale.LoadBalancer("loadBalancer01",
    load_balancer_name="terraform-public-load-balancer",
    subregion_names=[f"{var['region']}a"],
    listeners=[{
        "backend_port": 80,
        "backend_protocol": "TCP",
        "load_balancer_protocol": "TCP",
        "load_balancer_port": 80,
    }],
    tags=[{
        "key": "name",
        "value": "terraform-public-load-balancer",
    }])
outscale_load_balancer_vms01 = outscale.LoadBalancerVms("outscaleLoadBalancerVms01",
    load_balancer_name=load_balancer01.load_balancer_id,
    backend_vm_ids=[vm01.vm_id])

    package main

import (
	"fmt"

	"github.com/pulumi/pulumi-terraform-provider/sdks/go/outscale/outscale"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		vm01, err := outscale.NewVm(ctx, "vm01", &outscale.VmArgs{
			ImageId:     pulumi.Any(_var.Image_id),
			VmType:      pulumi.Any(_var.Vm_type),
			KeypairName: pulumi.Any(_var.Keypair_name),
		})
		if err != nil {
			return err
		}
		loadBalancer01, err := outscale.NewLoadBalancer(ctx, "loadBalancer01", &outscale.LoadBalancerArgs{
			LoadBalancerName: pulumi.String("terraform-public-load-balancer"),
			SubregionNames: pulumi.StringArray{
				pulumi.Sprintf("%va", _var.Region),
			},
			Listeners: outscale.LoadBalancerListenerArray{
				&outscale.LoadBalancerListenerArgs{
					BackendPort:          pulumi.Float64(80),
					BackendProtocol:      pulumi.String("TCP"),
					LoadBalancerProtocol: pulumi.String("TCP"),
					LoadBalancerPort:     pulumi.Float64(80),
				},
			},
			Tags: outscale.LoadBalancerTagArray{
				&outscale.LoadBalancerTagArgs{
					Key:   pulumi.String("name"),
					Value: pulumi.String("terraform-public-load-balancer"),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = outscale.NewLoadBalancerVms(ctx, "outscaleLoadBalancerVms01", &outscale.LoadBalancerVmsArgs{
			LoadBalancerName: loadBalancer01.LoadBalancerId,
			BackendVmIds: pulumi.StringArray{
				vm01.VmId,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var vm01 = new Outscale.Vm("vm01", new()
    {
        ImageId = @var.Image_id,
        VmType = @var.Vm_type,
        KeypairName = @var.Keypair_name,
    });

    var loadBalancer01 = new Outscale.LoadBalancer("loadBalancer01", new()
    {
        LoadBalancerName = "terraform-public-load-balancer",
        SubregionNames = new[]
        {
            $"{@var.Region}a",
        },
        Listeners = new[]
        {
            new Outscale.Inputs.LoadBalancerListenerArgs
            {
                BackendPort = 80,
                BackendProtocol = "TCP",
                LoadBalancerProtocol = "TCP",
                LoadBalancerPort = 80,
            },
        },
        Tags = new[]
        {
            new Outscale.Inputs.LoadBalancerTagArgs
            {
                Key = "name",
                Value = "terraform-public-load-balancer",
            },
        },
    });

    var outscaleLoadBalancerVms01 = new Outscale.LoadBalancerVms("outscaleLoadBalancerVms01", new()
    {
        LoadBalancerName = loadBalancer01.LoadBalancerId,
        BackendVmIds = new[]
        {
            vm01.VmId,
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.outscale.Vm;
import com.pulumi.outscale.VmArgs;
import com.pulumi.outscale.LoadBalancer;
import com.pulumi.outscale.LoadBalancerArgs;
import com.pulumi.outscale.inputs.LoadBalancerListenerArgs;
import com.pulumi.outscale.inputs.LoadBalancerTagArgs;
import com.pulumi.outscale.LoadBalancerVms;
import com.pulumi.outscale.LoadBalancerVmsArgs;
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 vm01 = new Vm("vm01", VmArgs.builder()
            .imageId(var_.image_id())
            .vmType(var_.vm_type())
            .keypairName(var_.keypair_name())
            .build());

        var loadBalancer01 = new LoadBalancer("loadBalancer01", LoadBalancerArgs.builder()
            .loadBalancerName("terraform-public-load-balancer")
            .subregionNames(String.format("%sa", var_.region()))
            .listeners(LoadBalancerListenerArgs.builder()
                .backendPort(80)
                .backendProtocol("TCP")
                .loadBalancerProtocol("TCP")
                .loadBalancerPort(80)
                .build())
            .tags(LoadBalancerTagArgs.builder()
                .key("name")
                .value("terraform-public-load-balancer")
                .build())
            .build());

        var outscaleLoadBalancerVms01 = new LoadBalancerVms("outscaleLoadBalancerVms01", LoadBalancerVmsArgs.builder()
            .loadBalancerName(loadBalancer01.loadBalancerId())
            .backendVmIds(vm01.vmId())
            .build());

    }
}

    resources:
  vm01:
    type: outscale:Vm
    properties:
      imageId: ${var.image_id}
      vmType: ${var.vm_type}
      keypairName: ${var.keypair_name}
  loadBalancer01:
    type: outscale:LoadBalancer
    properties:
      loadBalancerName: terraform-public-load-balancer
      subregionNames:
        - ${var.region}a
      listeners:
        - backendPort: 80
          backendProtocol: TCP
          loadBalancerProtocol: TCP
          loadBalancerPort: 80
      tags:
        - key: name
          value: terraform-public-load-balancer
  outscaleLoadBalancerVms01:
    type: outscale:LoadBalancerVms
    properties:
      loadBalancerName: ${loadBalancer01.loadBalancerId}
      backendVmIds:
        - ${vm01.vmId}

    Create a listener rule based on path pattern

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

const rule01 = new outscale.LoadBalancerListenerRule("rule01", {
    listener: {
        loadBalancerName: outscale_load_balancer.load_balancer01.id,
        loadBalancerPort: 80,
    },
    listenerRule: {
        action: "forward",
        listenerRuleName: "terraform-listener-rule01",
        pathPattern: "*.abc.*.abc.*.com",
        priority: 10,
    },
    vmIds: [outscale_vm.vm01.vm_id],
});

    import pulumi
import pulumi_outscale as outscale

rule01 = outscale.LoadBalancerListenerRule("rule01",
    listener={
        "load_balancer_name": outscale_load_balancer["load_balancer01"]["id"],
        "load_balancer_port": 80,
    },
    listener_rule={
        "action": "forward",
        "listener_rule_name": "terraform-listener-rule01",
        "path_pattern": "*.abc.*.abc.*.com",
        "priority": 10,
    },
    vm_ids=[outscale_vm["vm01"]["vm_id"]])

    package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/outscale/outscale"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := outscale.NewLoadBalancerListenerRule(ctx, "rule01", &outscale.LoadBalancerListenerRuleArgs{
			Listener: &outscale.LoadBalancerListenerRuleListenerArgs{
				LoadBalancerName: pulumi.Any(outscale_load_balancer.Load_balancer01.Id),
				LoadBalancerPort: pulumi.Float64(80),
			},
			ListenerRule: &outscale.LoadBalancerListenerRuleListenerRuleArgs{
				Action:           pulumi.String("forward"),
				ListenerRuleName: pulumi.String("terraform-listener-rule01"),
				PathPattern:      pulumi.String("*.abc.*.abc.*.com"),
				Priority:         pulumi.Float64(10),
			},
			VmIds: pulumi.StringArray{
				outscale_vm.Vm01.Vm_id,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var rule01 = new Outscale.LoadBalancerListenerRule("rule01", new()
    {
        Listener = new Outscale.Inputs.LoadBalancerListenerRuleListenerArgs
        {
            LoadBalancerName = outscale_load_balancer.Load_balancer01.Id,
            LoadBalancerPort = 80,
        },
        ListenerRule = new Outscale.Inputs.LoadBalancerListenerRuleListenerRuleArgs
        {
            Action = "forward",
            ListenerRuleName = "terraform-listener-rule01",
            PathPattern = "*.abc.*.abc.*.com",
            Priority = 10,
        },
        VmIds = new[]
        {
            outscale_vm.Vm01.Vm_id,
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.outscale.LoadBalancerListenerRule;
import com.pulumi.outscale.LoadBalancerListenerRuleArgs;
import com.pulumi.outscale.inputs.LoadBalancerListenerRuleListenerArgs;
import com.pulumi.outscale.inputs.LoadBalancerListenerRuleListenerRuleArgs;
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 rule01 = new LoadBalancerListenerRule("rule01", LoadBalancerListenerRuleArgs.builder()
            .listener(LoadBalancerListenerRuleListenerArgs.builder()
                .loadBalancerName(outscale_load_balancer.load_balancer01().id())
                .loadBalancerPort(80)
                .build())
            .listenerRule(LoadBalancerListenerRuleListenerRuleArgs.builder()
                .action("forward")
                .listenerRuleName("terraform-listener-rule01")
                .pathPattern("*.abc.*.abc.*.com")
                .priority(10)
                .build())
            .vmIds(outscale_vm.vm01().vm_id())
            .build());

    }
}

    resources:
  rule01:
    type: outscale:LoadBalancerListenerRule
    properties:
      listener:
        loadBalancerName: ${outscale_load_balancer.load_balancer01.id}
        loadBalancerPort: 80
      listenerRule:
        action: forward
        listenerRuleName: terraform-listener-rule01
        pathPattern: '*.abc.*.abc.*.com'
        priority: 10
      vmIds:
        - ${outscale_vm.vm01.vm_id}

    Create a listener rule based on host pattern

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

const rule02 = new outscale.LoadBalancerListenerRule("rule02", {
    listener: {
        loadBalancerName: outscale_load_balancer.load_balancer01.id,
        loadBalancerPort: 80,
    },
    listenerRule: {
        action: "forward",
        listenerRuleName: "terraform-listener-rule02",
        hostNamePattern: "*.abc.-.abc.*.com",
        priority: 1,
    },
    vmIds: [outscale_vm.vm01.vm_id],
});

    import pulumi
import pulumi_outscale as outscale

rule02 = outscale.LoadBalancerListenerRule("rule02",
    listener={
        "load_balancer_name": outscale_load_balancer["load_balancer01"]["id"],
        "load_balancer_port": 80,
    },
    listener_rule={
        "action": "forward",
        "listener_rule_name": "terraform-listener-rule02",
        "host_name_pattern": "*.abc.-.abc.*.com",
        "priority": 1,
    },
    vm_ids=[outscale_vm["vm01"]["vm_id"]])

    package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/outscale/outscale"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := outscale.NewLoadBalancerListenerRule(ctx, "rule02", &outscale.LoadBalancerListenerRuleArgs{
			Listener: &outscale.LoadBalancerListenerRuleListenerArgs{
				LoadBalancerName: pulumi.Any(outscale_load_balancer.Load_balancer01.Id),
				LoadBalancerPort: pulumi.Float64(80),
			},
			ListenerRule: &outscale.LoadBalancerListenerRuleListenerRuleArgs{
				Action:           pulumi.String("forward"),
				ListenerRuleName: pulumi.String("terraform-listener-rule02"),
				HostNamePattern:  pulumi.String("*.abc.-.abc.*.com"),
				Priority:         pulumi.Float64(1),
			},
			VmIds: pulumi.StringArray{
				outscale_vm.Vm01.Vm_id,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var rule02 = new Outscale.LoadBalancerListenerRule("rule02", new()
    {
        Listener = new Outscale.Inputs.LoadBalancerListenerRuleListenerArgs
        {
            LoadBalancerName = outscale_load_balancer.Load_balancer01.Id,
            LoadBalancerPort = 80,
        },
        ListenerRule = new Outscale.Inputs.LoadBalancerListenerRuleListenerRuleArgs
        {
            Action = "forward",
            ListenerRuleName = "terraform-listener-rule02",
            HostNamePattern = "*.abc.-.abc.*.com",
            Priority = 1,
        },
        VmIds = new[]
        {
            outscale_vm.Vm01.Vm_id,
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.outscale.LoadBalancerListenerRule;
import com.pulumi.outscale.LoadBalancerListenerRuleArgs;
import com.pulumi.outscale.inputs.LoadBalancerListenerRuleListenerArgs;
import com.pulumi.outscale.inputs.LoadBalancerListenerRuleListenerRuleArgs;
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 rule02 = new LoadBalancerListenerRule("rule02", LoadBalancerListenerRuleArgs.builder()
            .listener(LoadBalancerListenerRuleListenerArgs.builder()
                .loadBalancerName(outscale_load_balancer.load_balancer01().id())
                .loadBalancerPort(80)
                .build())
            .listenerRule(LoadBalancerListenerRuleListenerRuleArgs.builder()
                .action("forward")
                .listenerRuleName("terraform-listener-rule02")
                .hostNamePattern("*.abc.-.abc.*.com")
                .priority(1)
                .build())
            .vmIds(outscale_vm.vm01().vm_id())
            .build());

    }
}

    resources:
  rule02:
    type: outscale:LoadBalancerListenerRule
    properties:
      listener:
        loadBalancerName: ${outscale_load_balancer.load_balancer01.id}
        loadBalancerPort: 80
      listenerRule:
        action: forward
        listenerRuleName: terraform-listener-rule02
        hostNamePattern: '*.abc.-.abc.*.com'
        priority: 1
      vmIds:
        - ${outscale_vm.vm01.vm_id}

    Create LoadBalancerListenerRule Resource

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

    Constructor syntax

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

@overload
def LoadBalancerListenerRule(resource_name: str,
                             opts: Optional[ResourceOptions] = None,
                             listener: Optional[LoadBalancerListenerRuleListenerArgs] = None,
                             listener_rule: Optional[LoadBalancerListenerRuleListenerRuleArgs] = None,
                             vm_ids: Optional[Sequence[str]] = None,
                             load_balancer_listener_rule_id: Optional[str] = None)
    func NewLoadBalancerListenerRule(ctx *Context, name string, args LoadBalancerListenerRuleArgs, opts ...ResourceOption) (*LoadBalancerListenerRule, error)
    public LoadBalancerListenerRule(string name, LoadBalancerListenerRuleArgs args, CustomResourceOptions? opts = null)
    public LoadBalancerListenerRule(String name, LoadBalancerListenerRuleArgs args)
public LoadBalancerListenerRule(String name, LoadBalancerListenerRuleArgs args, CustomResourceOptions options)

    type: outscale:LoadBalancerListenerRule
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 LoadBalancerListenerRuleArgs
    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 LoadBalancerListenerRuleArgs
    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 LoadBalancerListenerRuleArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args LoadBalancerListenerRuleArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args LoadBalancerListenerRuleArgs
    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 loadBalancerListenerRuleResource = new Outscale.LoadBalancerListenerRule("loadBalancerListenerRuleResource", new()
{
    Listener = new Outscale.Inputs.LoadBalancerListenerRuleListenerArgs
    {
        LoadBalancerName = "string",
        LoadBalancerPort = 0,
    },
    ListenerRule = new Outscale.Inputs.LoadBalancerListenerRuleListenerRuleArgs
    {
        ListenerRuleName = "string",
        Priority = 0,
        Action = "string",
        HostNamePattern = "string",
        ListenerId = 0,
        ListenerRuleId = 0,
        PathPattern = "string",
    },
    VmIds = new[]
    {
        "string",
    },
    LoadBalancerListenerRuleId = "string",
});

    example, err := outscale.NewLoadBalancerListenerRule(ctx, "loadBalancerListenerRuleResource", &outscale.LoadBalancerListenerRuleArgs{
Listener: &.LoadBalancerListenerRuleListenerArgs{
LoadBalancerName: pulumi.String("string"),
LoadBalancerPort: pulumi.Float64(0),
},
ListenerRule: &.LoadBalancerListenerRuleListenerRuleArgs{
ListenerRuleName: pulumi.String("string"),
Priority: pulumi.Float64(0),
Action: pulumi.String("string"),
HostNamePattern: pulumi.String("string"),
ListenerId: pulumi.Float64(0),
ListenerRuleId: pulumi.Float64(0),
PathPattern: pulumi.String("string"),
},
VmIds: pulumi.StringArray{
pulumi.String("string"),
},
LoadBalancerListenerRuleId: pulumi.String("string"),
})

    var loadBalancerListenerRuleResource = new LoadBalancerListenerRule("loadBalancerListenerRuleResource", LoadBalancerListenerRuleArgs.builder()
    .listener(LoadBalancerListenerRuleListenerArgs.builder()
        .loadBalancerName("string")
        .loadBalancerPort(0)
        .build())
    .listenerRule(LoadBalancerListenerRuleListenerRuleArgs.builder()
        .listenerRuleName("string")
        .priority(0)
        .action("string")
        .hostNamePattern("string")
        .listenerId(0)
        .listenerRuleId(0)
        .pathPattern("string")
        .build())
    .vmIds("string")
    .loadBalancerListenerRuleId("string")
    .build());

    load_balancer_listener_rule_resource = outscale.LoadBalancerListenerRule("loadBalancerListenerRuleResource",
    listener={
        "load_balancer_name": "string",
        "load_balancer_port": 0,
    },
    listener_rule={
        "listener_rule_name": "string",
        "priority": 0,
        "action": "string",
        "host_name_pattern": "string",
        "listener_id": 0,
        "listener_rule_id": 0,
        "path_pattern": "string",
    },
    vm_ids=["string"],
    load_balancer_listener_rule_id="string")

    const loadBalancerListenerRuleResource = new outscale.LoadBalancerListenerRule("loadBalancerListenerRuleResource", {
    listener: {
        loadBalancerName: "string",
        loadBalancerPort: 0,
    },
    listenerRule: {
        listenerRuleName: "string",
        priority: 0,
        action: "string",
        hostNamePattern: "string",
        listenerId: 0,
        listenerRuleId: 0,
        pathPattern: "string",
    },
    vmIds: ["string"],
    loadBalancerListenerRuleId: "string",
});

    type: outscale:LoadBalancerListenerRule
properties:
    listener:
        loadBalancerName: string
        loadBalancerPort: 0
    listenerRule:
        action: string
        hostNamePattern: string
        listenerId: 0
        listenerRuleId: 0
        listenerRuleName: string
        pathPattern: string
        priority: 0
    loadBalancerListenerRuleId: string
    vmIds:
        - string

    LoadBalancerListenerRule 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 LoadBalancerListenerRule resource accepts the following input properties:

    Listener LoadBalancerListenerRuleListener
    Information about the load balancer.
    ListenerRule LoadBalancerListenerRuleListenerRule
    Information about the listener rule.
    VmIds List<string>
    The IDs of the backend VMs.
    LoadBalancerListenerRuleId string
    Listener LoadBalancerListenerRuleListenerArgs
    Information about the load balancer.
    ListenerRule LoadBalancerListenerRuleListenerRuleArgs
    Information about the listener rule.
    VmIds []string
    The IDs of the backend VMs.
    LoadBalancerListenerRuleId string
    listener LoadBalancerListenerRuleListener
    Information about the load balancer.
    listenerRule LoadBalancerListenerRuleListenerRule
    Information about the listener rule.
    vmIds List<String>
    The IDs of the backend VMs.
    loadBalancerListenerRuleId String
    listener LoadBalancerListenerRuleListener
    Information about the load balancer.
    listenerRule LoadBalancerListenerRuleListenerRule
    Information about the listener rule.
    vmIds string[]
    The IDs of the backend VMs.
    loadBalancerListenerRuleId string
    listener LoadBalancerListenerRuleListenerArgs
    Information about the load balancer.
    listener_rule LoadBalancerListenerRuleListenerRuleArgs
    Information about the listener rule.
    vm_ids Sequence[str]
    The IDs of the backend VMs.
    load_balancer_listener_rule_id str
    listener Property Map
    Information about the load balancer.
    listenerRule Property Map
    Information about the listener rule.
    vmIds List<String>
    The IDs of the backend VMs.
    loadBalancerListenerRuleId String

    Outputs

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

    Id string
    The provider-assigned unique ID for this managed resource.
    RequestId string
    Id string
    The provider-assigned unique ID for this managed resource.
    RequestId string
    id String
    The provider-assigned unique ID for this managed resource.
    requestId String
    id string
    The provider-assigned unique ID for this managed resource.
    requestId string
    id str
    The provider-assigned unique ID for this managed resource.
    request_id str
    id String
    The provider-assigned unique ID for this managed resource.
    requestId String

    Look up Existing LoadBalancerListenerRule Resource

    Get an existing LoadBalancerListenerRule 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?: LoadBalancerListenerRuleState, opts?: CustomResourceOptions): LoadBalancerListenerRule
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        listener: Optional[LoadBalancerListenerRuleListenerArgs] = None,
        listener_rule: Optional[LoadBalancerListenerRuleListenerRuleArgs] = None,
        load_balancer_listener_rule_id: Optional[str] = None,
        request_id: Optional[str] = None,
        vm_ids: Optional[Sequence[str]] = None) -> LoadBalancerListenerRule
    func GetLoadBalancerListenerRule(ctx *Context, name string, id IDInput, state *LoadBalancerListenerRuleState, opts ...ResourceOption) (*LoadBalancerListenerRule, error)
    public static LoadBalancerListenerRule Get(string name, Input<string> id, LoadBalancerListenerRuleState? state, CustomResourceOptions? opts = null)
    public static LoadBalancerListenerRule get(String name, Output<String> id, LoadBalancerListenerRuleState state, CustomResourceOptions options)
    resources:  _:    type: outscale:LoadBalancerListenerRule    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:
    Listener LoadBalancerListenerRuleListener
    Information about the load balancer.
    ListenerRule LoadBalancerListenerRuleListenerRule
    Information about the listener rule.
    LoadBalancerListenerRuleId string
    RequestId string
    VmIds List<string>
    The IDs of the backend VMs.
    Listener LoadBalancerListenerRuleListenerArgs
    Information about the load balancer.
    ListenerRule LoadBalancerListenerRuleListenerRuleArgs
    Information about the listener rule.
    LoadBalancerListenerRuleId string
    RequestId string
    VmIds []string
    The IDs of the backend VMs.
    listener LoadBalancerListenerRuleListener
    Information about the load balancer.
    listenerRule LoadBalancerListenerRuleListenerRule
    Information about the listener rule.
    loadBalancerListenerRuleId String
    requestId String
    vmIds List<String>
    The IDs of the backend VMs.
    listener LoadBalancerListenerRuleListener
    Information about the load balancer.
    listenerRule LoadBalancerListenerRuleListenerRule
    Information about the listener rule.
    loadBalancerListenerRuleId string
    requestId string
    vmIds string[]
    The IDs of the backend VMs.
    listener LoadBalancerListenerRuleListenerArgs
    Information about the load balancer.
    listener_rule LoadBalancerListenerRuleListenerRuleArgs
    Information about the listener rule.
    load_balancer_listener_rule_id str
    request_id str
    vm_ids Sequence[str]
    The IDs of the backend VMs.
    listener Property Map
    Information about the load balancer.
    listenerRule Property Map
    Information about the listener rule.
    loadBalancerListenerRuleId String
    requestId String
    vmIds List<String>
    The IDs of the backend VMs.

    Supporting Types

    LoadBalancerListenerRuleListener, LoadBalancerListenerRuleListenerArgs

    LoadBalancerName string
    The name of the load balancer to which the listener is attached.
    LoadBalancerPort double
    The port of load balancer on which the load balancer is listening (between 1 and 65535 both included).
    LoadBalancerName string
    The name of the load balancer to which the listener is attached.
    LoadBalancerPort float64
    The port of load balancer on which the load balancer is listening (between 1 and 65535 both included).
    loadBalancerName String
    The name of the load balancer to which the listener is attached.
    loadBalancerPort Double
    The port of load balancer on which the load balancer is listening (between 1 and 65535 both included).
    loadBalancerName string
    The name of the load balancer to which the listener is attached.
    loadBalancerPort number
    The port of load balancer on which the load balancer is listening (between 1 and 65535 both included).
    load_balancer_name str
    The name of the load balancer to which the listener is attached.
    load_balancer_port float
    The port of load balancer on which the load balancer is listening (between 1 and 65535 both included).
    loadBalancerName String
    The name of the load balancer to which the listener is attached.
    loadBalancerPort Number
    The port of load balancer on which the load balancer is listening (between 1 and 65535 both included).

    LoadBalancerListenerRuleListenerRule, LoadBalancerListenerRuleListenerRuleArgs

    ListenerRuleName string
    A human-readable name for the listener rule.
    Priority double
    The priority level of the listener rule, between 1 and 19999 both included. Each rule must have a unique priority level. Otherwise, an error is returned.
    Action string
    The type of action for the rule (always forward).
    HostNamePattern string
    A host-name pattern for the rule, with a maximum length of 128 characters. This host-name pattern supports maximum three wildcards, and must not contain any special characters except -.?.
    ListenerId double
    The ID of the listener.
    ListenerRuleId double
    The ID of the listener rule.
    PathPattern string
    A path pattern for the rule, with a maximum length of 128 characters. This path pattern supports maximum three wildcards, and must not contain any special characters except _-.$/~&quot;'@:+?.
    ListenerRuleName string
    A human-readable name for the listener rule.
    Priority float64
    The priority level of the listener rule, between 1 and 19999 both included. Each rule must have a unique priority level. Otherwise, an error is returned.
    Action string
    The type of action for the rule (always forward).
    HostNamePattern string
    A host-name pattern for the rule, with a maximum length of 128 characters. This host-name pattern supports maximum three wildcards, and must not contain any special characters except -.?.
    ListenerId float64
    The ID of the listener.
    ListenerRuleId float64
    The ID of the listener rule.
    PathPattern string
    A path pattern for the rule, with a maximum length of 128 characters. This path pattern supports maximum three wildcards, and must not contain any special characters except _-.$/~&quot;'@:+?.
    listenerRuleName String
    A human-readable name for the listener rule.
    priority Double
    The priority level of the listener rule, between 1 and 19999 both included. Each rule must have a unique priority level. Otherwise, an error is returned.
    action String
    The type of action for the rule (always forward).
    hostNamePattern String
    A host-name pattern for the rule, with a maximum length of 128 characters. This host-name pattern supports maximum three wildcards, and must not contain any special characters except -.?.
    listenerId Double
    The ID of the listener.
    listenerRuleId Double
    The ID of the listener rule.
    pathPattern String
    A path pattern for the rule, with a maximum length of 128 characters. This path pattern supports maximum three wildcards, and must not contain any special characters except _-.$/~&quot;'@:+?.
    listenerRuleName string
    A human-readable name for the listener rule.
    priority number
    The priority level of the listener rule, between 1 and 19999 both included. Each rule must have a unique priority level. Otherwise, an error is returned.
    action string
    The type of action for the rule (always forward).
    hostNamePattern string
    A host-name pattern for the rule, with a maximum length of 128 characters. This host-name pattern supports maximum three wildcards, and must not contain any special characters except -.?.
    listenerId number
    The ID of the listener.
    listenerRuleId number
    The ID of the listener rule.
    pathPattern string
    A path pattern for the rule, with a maximum length of 128 characters. This path pattern supports maximum three wildcards, and must not contain any special characters except _-.$/~&quot;'@:+?.
    listener_rule_name str
    A human-readable name for the listener rule.
    priority float
    The priority level of the listener rule, between 1 and 19999 both included. Each rule must have a unique priority level. Otherwise, an error is returned.
    action str
    The type of action for the rule (always forward).
    host_name_pattern str
    A host-name pattern for the rule, with a maximum length of 128 characters. This host-name pattern supports maximum three wildcards, and must not contain any special characters except -.?.
    listener_id float
    The ID of the listener.
    listener_rule_id float
    The ID of the listener rule.
    path_pattern str
    A path pattern for the rule, with a maximum length of 128 characters. This path pattern supports maximum three wildcards, and must not contain any special characters except _-.$/~&quot;'@:+?.
    listenerRuleName String
    A human-readable name for the listener rule.
    priority Number
    The priority level of the listener rule, between 1 and 19999 both included. Each rule must have a unique priority level. Otherwise, an error is returned.
    action String
    The type of action for the rule (always forward).
    hostNamePattern String
    A host-name pattern for the rule, with a maximum length of 128 characters. This host-name pattern supports maximum three wildcards, and must not contain any special characters except -.?.
    listenerId Number
    The ID of the listener.
    listenerRuleId Number
    The ID of the listener rule.
    pathPattern String
    A path pattern for the rule, with a maximum length of 128 characters. This path pattern supports maximum three wildcards, and must not contain any special characters except _-.$/~&quot;'@:+?.

    Package Details

    Repository
    outscale outscale/terraform-provider-outscale
    License
    Notes
    This Pulumi package is based on the outscale Terraform Provider.
    outscale logo
    outscale 1.0.1 published on Thursday, Mar 13, 2025 by outscale
    outscale/terraform-provider-outscale