Docs Home Pulumi IaC Pulumi ESC Pulumi Insights Pulumi Cloud Packages Tutorials
  1. Packages
  2. Ionoscloud
  3. API Docs
  4. nlb
  5. ForwardingRule
IonosCloud v0.2.3 published on Tuesday, May 13, 2025 by ionos-cloud
ionos-cloud/pulumi-ionoscloud

ionoscloud.nlb.ForwardingRule

Explore with Pulumi AI

ionoscloud logo
IonosCloud v0.2.3 published on Tuesday, May 13, 2025 by ionos-cloud
ionos-cloud/pulumi-ionoscloud

    Manages a Network Load Balancer Forwarding Rule on IonosCloud.

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
import * as ionoscloud from "@ionos-cloud/sdk-pulumi";

const example = new ionoscloud.compute.Datacenter("example", {
    name: "Datacenter Example",
    location: "us/las",
    description: "Datacenter Description",
    secAuthProtection: false,
});
const example1 = new ionoscloud.compute.Lan("example1", {
    datacenterId: example.id,
    "public": false,
    name: "Lan Example 1",
});
const example2 = new ionoscloud.compute.Lan("example2", {
    datacenterId: example.id,
    "public": false,
    name: "Lan Example 2",
});
const exampleBalancer = new ionoscloud.nlb.Balancer("example", {
    datacenterId: example.id,
    name: "example",
    listenerLan: example1.id,
    targetLan: example2.id,
    ips: ["10.12.118.224"],
    lbPrivateIps: ["10.13.72.225/24"],
});
const exampleForwardingRule = new ionoscloud.nlb.ForwardingRule("example", {
    datacenterId: example.id,
    networkloadbalancerId: exampleBalancer.id,
    name: "example",
    algorithm: "SOURCE_IP",
    protocol: "TCP",
    listenerIp: "10.12.118.224",
    listenerPort: 8081,
    targets: [{
        ip: "22.231.2.2",
        port: 8080,
        weight: 123,
        proxyProtocol: "v1",
        healthCheck: {
            check: true,
            checkInterval: 1000,
        },
    }],
});

    import pulumi
import pulumi_ionoscloud as ionoscloud

example = ionoscloud.compute.Datacenter("example",
    name="Datacenter Example",
    location="us/las",
    description="Datacenter Description",
    sec_auth_protection=False)
example1 = ionoscloud.compute.Lan("example1",
    datacenter_id=example.id,
    public=False,
    name="Lan Example 1")
example2 = ionoscloud.compute.Lan("example2",
    datacenter_id=example.id,
    public=False,
    name="Lan Example 2")
example_balancer = ionoscloud.nlb.Balancer("example",
    datacenter_id=example.id,
    name="example",
    listener_lan=example1.id,
    target_lan=example2.id,
    ips=["10.12.118.224"],
    lb_private_ips=["10.13.72.225/24"])
example_forwarding_rule = ionoscloud.nlb.ForwardingRule("example",
    datacenter_id=example.id,
    networkloadbalancer_id=example_balancer.id,
    name="example",
    algorithm="SOURCE_IP",
    protocol="TCP",
    listener_ip="10.12.118.224",
    listener_port=8081,
    targets=[{
        "ip": "22.231.2.2",
        "port": 8080,
        "weight": 123,
        "proxy_protocol": "v1",
        "health_check": {
            "check": True,
            "check_interval": 1000,
        },
    }])

    package main

import (
	"github.com/ionos-cloud/pulumi-ionoscloud/sdk/go/ionoscloud/compute"
	"github.com/ionos-cloud/pulumi-ionoscloud/sdk/go/ionoscloud/nlb"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := compute.NewDatacenter(ctx, "example", &compute.DatacenterArgs{
			Name:              pulumi.String("Datacenter Example"),
			Location:          pulumi.String("us/las"),
			Description:       pulumi.String("Datacenter Description"),
			SecAuthProtection: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		example1, err := compute.NewLan(ctx, "example1", &compute.LanArgs{
			DatacenterId: example.ID(),
			Public:       pulumi.Bool(false),
			Name:         pulumi.String("Lan Example 1"),
		})
		if err != nil {
			return err
		}
		example2, err := compute.NewLan(ctx, "example2", &compute.LanArgs{
			DatacenterId: example.ID(),
			Public:       pulumi.Bool(false),
			Name:         pulumi.String("Lan Example 2"),
		})
		if err != nil {
			return err
		}
		exampleBalancer, err := nlb.NewBalancer(ctx, "example", &nlb.BalancerArgs{
			DatacenterId: example.ID(),
			Name:         pulumi.String("example"),
			ListenerLan:  example1.ID(),
			TargetLan:    example2.ID(),
			Ips: pulumi.StringArray{
				pulumi.String("10.12.118.224"),
			},
			LbPrivateIps: pulumi.StringArray{
				pulumi.String("10.13.72.225/24"),
			},
		})
		if err != nil {
			return err
		}
		_, err = nlb.NewForwardingRule(ctx, "example", &nlb.ForwardingRuleArgs{
			DatacenterId:          example.ID(),
			NetworkloadbalancerId: exampleBalancer.ID(),
			Name:                  pulumi.String("example"),
			Algorithm:             pulumi.String("SOURCE_IP"),
			Protocol:              pulumi.String("TCP"),
			ListenerIp:            pulumi.String("10.12.118.224"),
			ListenerPort:          pulumi.Int(8081),
			Targets: nlb.ForwardingRuleTargetArray{
				&nlb.ForwardingRuleTargetArgs{
					Ip:            pulumi.String("22.231.2.2"),
					Port:          pulumi.Int(8080),
					Weight:        pulumi.Int(123),
					ProxyProtocol: pulumi.String("v1"),
					HealthCheck: &nlb.ForwardingRuleTargetHealthCheckArgs{
						Check:         pulumi.Bool(true),
						CheckInterval: pulumi.Int(1000),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = new Ionoscloud.Compute.Datacenter("example", new()
    {
        Name = "Datacenter Example",
        Location = "us/las",
        Description = "Datacenter Description",
        SecAuthProtection = false,
    });

    var example1 = new Ionoscloud.Compute.Lan("example1", new()
    {
        DatacenterId = example.Id,
        Public = false,
        Name = "Lan Example 1",
    });

    var example2 = new Ionoscloud.Compute.Lan("example2", new()
    {
        DatacenterId = example.Id,
        Public = false,
        Name = "Lan Example 2",
    });

    var exampleBalancer = new Ionoscloud.Nlb.Balancer("example", new()
    {
        DatacenterId = example.Id,
        Name = "example",
        ListenerLan = example1.Id,
        TargetLan = example2.Id,
        Ips = new[]
        {
            "10.12.118.224",
        },
        LbPrivateIps = new[]
        {
            "10.13.72.225/24",
        },
    });

    var exampleForwardingRule = new Ionoscloud.Nlb.ForwardingRule("example", new()
    {
        DatacenterId = example.Id,
        NetworkloadbalancerId = exampleBalancer.Id,
        Name = "example",
        Algorithm = "SOURCE_IP",
        Protocol = "TCP",
        ListenerIp = "10.12.118.224",
        ListenerPort = 8081,
        Targets = new[]
        {
            new Ionoscloud.Nlb.Inputs.ForwardingRuleTargetArgs
            {
                Ip = "22.231.2.2",
                Port = 8080,
                Weight = 123,
                ProxyProtocol = "v1",
                HealthCheck = new Ionoscloud.Nlb.Inputs.ForwardingRuleTargetHealthCheckArgs
                {
                    Check = true,
                    CheckInterval = 1000,
                },
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.ionoscloud.compute.Datacenter;
import com.pulumi.ionoscloud.compute.DatacenterArgs;
import com.pulumi.ionoscloud.compute.Lan;
import com.pulumi.ionoscloud.compute.LanArgs;
import com.pulumi.ionoscloud.nlb.Balancer;
import com.pulumi.ionoscloud.nlb.BalancerArgs;
import com.pulumi.ionoscloud.nlb.ForwardingRule;
import com.pulumi.ionoscloud.nlb.ForwardingRuleArgs;
import com.pulumi.ionoscloud.nlb.inputs.ForwardingRuleTargetArgs;
import com.pulumi.ionoscloud.nlb.inputs.ForwardingRuleTargetHealthCheckArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new Datacenter("example", DatacenterArgs.builder()
            .name("Datacenter Example")
            .location("us/las")
            .description("Datacenter Description")
            .secAuthProtection(false)
            .build());

        var example1 = new Lan("example1", LanArgs.builder()
            .datacenterId(example.id())
            .public_(false)
            .name("Lan Example 1")
            .build());

        var example2 = new Lan("example2", LanArgs.builder()
            .datacenterId(example.id())
            .public_(false)
            .name("Lan Example 2")
            .build());

        var exampleBalancer = new Balancer("exampleBalancer", BalancerArgs.builder()
            .datacenterId(example.id())
            .name("example")
            .listenerLan(example1.id())
            .targetLan(example2.id())
            .ips("10.12.118.224")
            .lbPrivateIps("10.13.72.225/24")
            .build());

        var exampleForwardingRule = new ForwardingRule("exampleForwardingRule", ForwardingRuleArgs.builder()
            .datacenterId(example.id())
            .networkloadbalancerId(exampleBalancer.id())
            .name("example")
            .algorithm("SOURCE_IP")
            .protocol("TCP")
            .listenerIp("10.12.118.224")
            .listenerPort("8081")
            .targets(ForwardingRuleTargetArgs.builder()
                .ip("22.231.2.2")
                .port("8080")
                .weight("123")
                .proxyProtocol("v1")
                .healthCheck(ForwardingRuleTargetHealthCheckArgs.builder()
                    .check(true)
                    .checkInterval(1000)
                    .build())
                .build())
            .build());

    }
}

    resources:
  example:
    type: ionoscloud:compute:Datacenter
    properties:
      name: Datacenter Example
      location: us/las
      description: Datacenter Description
      secAuthProtection: false
  example1:
    type: ionoscloud:compute:Lan
    properties:
      datacenterId: ${example.id}
      public: false
      name: Lan Example 1
  example2:
    type: ionoscloud:compute:Lan
    properties:
      datacenterId: ${example.id}
      public: false
      name: Lan Example 2
  exampleBalancer:
    type: ionoscloud:nlb:Balancer
    name: example
    properties:
      datacenterId: ${example.id}
      name: example
      listenerLan: ${example1.id}
      targetLan: ${example2.id}
      ips:
        - 10.12.118.224
      lbPrivateIps:
        - 10.13.72.225/24
  exampleForwardingRule:
    type: ionoscloud:nlb:ForwardingRule
    name: example
    properties:
      datacenterId: ${example.id}
      networkloadbalancerId: ${exampleBalancer.id}
      name: example
      algorithm: SOURCE_IP
      protocol: TCP
      listenerIp: 10.12.118.224
      listenerPort: '8081'
      targets:
        - ip: 22.231.2.2
          port: '8080'
          weight: '123'
          proxyProtocol: v1
          healthCheck:
            check: true
            checkInterval: 1000

    Create ForwardingRule Resource

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

    Constructor syntax

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

@overload
def ForwardingRule(resource_name: str,
                   opts: Optional[ResourceOptions] = None,
                   algorithm: Optional[str] = None,
                   datacenter_id: Optional[str] = None,
                   listener_ip: Optional[str] = None,
                   listener_port: Optional[int] = None,
                   networkloadbalancer_id: Optional[str] = None,
                   protocol: Optional[str] = None,
                   targets: Optional[Sequence[ForwardingRuleTargetArgs]] = None,
                   health_check: Optional[ForwardingRuleHealthCheckArgs] = None,
                   name: Optional[str] = None)
    func NewForwardingRule(ctx *Context, name string, args ForwardingRuleArgs, opts ...ResourceOption) (*ForwardingRule, error)
    public ForwardingRule(string name, ForwardingRuleArgs args, CustomResourceOptions? opts = null)
    public ForwardingRule(String name, ForwardingRuleArgs args)
public ForwardingRule(String name, ForwardingRuleArgs args, CustomResourceOptions options)

    type: ionoscloud:nlb:ForwardingRule
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 ForwardingRuleArgs
    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 ForwardingRuleArgs
    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 ForwardingRuleArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args ForwardingRuleArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args ForwardingRuleArgs
    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 ionoscloudForwardingRuleResource = new Ionoscloud.Nlb.ForwardingRule("ionoscloudForwardingRuleResource", new()
{
    Algorithm = "string",
    DatacenterId = "string",
    ListenerIp = "string",
    ListenerPort = 0,
    NetworkloadbalancerId = "string",
    Protocol = "string",
    Targets = new[]
    {
        new Ionoscloud.Nlb.Inputs.ForwardingRuleTargetArgs
        {
            Ip = "string",
            Port = 0,
            Weight = 0,
            HealthCheck = new Ionoscloud.Nlb.Inputs.ForwardingRuleTargetHealthCheckArgs
            {
                Check = false,
                CheckInterval = 0,
                Maintenance = false,
            },
            ProxyProtocol = "string",
        },
    },
    HealthCheck = new Ionoscloud.Nlb.Inputs.ForwardingRuleHealthCheckArgs
    {
        ClientTimeout = 0,
        ConnectTimeout = 0,
        Retries = 0,
        TargetTimeout = 0,
    },
    Name = "string",
});

    example, err := nlb.NewForwardingRule(ctx, "ionoscloudForwardingRuleResource", &nlb.ForwardingRuleArgs{
	Algorithm:             pulumi.String("string"),
	DatacenterId:          pulumi.String("string"),
	ListenerIp:            pulumi.String("string"),
	ListenerPort:          pulumi.Int(0),
	NetworkloadbalancerId: pulumi.String("string"),
	Protocol:              pulumi.String("string"),
	Targets: nlb.ForwardingRuleTargetArray{
		&nlb.ForwardingRuleTargetArgs{
			Ip:     pulumi.String("string"),
			Port:   pulumi.Int(0),
			Weight: pulumi.Int(0),
			HealthCheck: &nlb.ForwardingRuleTargetHealthCheckArgs{
				Check:         pulumi.Bool(false),
				CheckInterval: pulumi.Int(0),
				Maintenance:   pulumi.Bool(false),
			},
			ProxyProtocol: pulumi.String("string"),
		},
	},
	HealthCheck: &nlb.ForwardingRuleHealthCheckArgs{
		ClientTimeout:  pulumi.Int(0),
		ConnectTimeout: pulumi.Int(0),
		Retries:        pulumi.Int(0),
		TargetTimeout:  pulumi.Int(0),
	},
	Name: pulumi.String("string"),
})

    var ionoscloudForwardingRuleResource = new com.ionoscloud.pulumi.ionoscloud.nlb.ForwardingRule("ionoscloudForwardingRuleResource", com.ionoscloud.pulumi.ionoscloud.nlb.ForwardingRuleArgs.builder()
    .algorithm("string")
    .datacenterId("string")
    .listenerIp("string")
    .listenerPort(0)
    .networkloadbalancerId("string")
    .protocol("string")
    .targets(ForwardingRuleTargetArgs.builder()
        .ip("string")
        .port(0)
        .weight(0)
        .healthCheck(ForwardingRuleTargetHealthCheckArgs.builder()
            .check(false)
            .checkInterval(0)
            .maintenance(false)
            .build())
        .proxyProtocol("string")
        .build())
    .healthCheck(ForwardingRuleHealthCheckArgs.builder()
        .clientTimeout(0)
        .connectTimeout(0)
        .retries(0)
        .targetTimeout(0)
        .build())
    .name("string")
    .build());

    ionoscloud_forwarding_rule_resource = ionoscloud.nlb.ForwardingRule("ionoscloudForwardingRuleResource",
    algorithm="string",
    datacenter_id="string",
    listener_ip="string",
    listener_port=0,
    networkloadbalancer_id="string",
    protocol="string",
    targets=[{
        "ip": "string",
        "port": 0,
        "weight": 0,
        "health_check": {
            "check": False,
            "check_interval": 0,
            "maintenance": False,
        },
        "proxy_protocol": "string",
    }],
    health_check={
        "client_timeout": 0,
        "connect_timeout": 0,
        "retries": 0,
        "target_timeout": 0,
    },
    name="string")

    const ionoscloudForwardingRuleResource = new ionoscloud.nlb.ForwardingRule("ionoscloudForwardingRuleResource", {
    algorithm: "string",
    datacenterId: "string",
    listenerIp: "string",
    listenerPort: 0,
    networkloadbalancerId: "string",
    protocol: "string",
    targets: [{
        ip: "string",
        port: 0,
        weight: 0,
        healthCheck: {
            check: false,
            checkInterval: 0,
            maintenance: false,
        },
        proxyProtocol: "string",
    }],
    healthCheck: {
        clientTimeout: 0,
        connectTimeout: 0,
        retries: 0,
        targetTimeout: 0,
    },
    name: "string",
});

    type: ionoscloud:nlb:ForwardingRule
properties:
    algorithm: string
    datacenterId: string
    healthCheck:
        clientTimeout: 0
        connectTimeout: 0
        retries: 0
        targetTimeout: 0
    listenerIp: string
    listenerPort: 0
    name: string
    networkloadbalancerId: string
    protocol: string
    targets:
        - healthCheck:
            check: false
            checkInterval: 0
            maintenance: false
          ip: string
          port: 0
          proxyProtocol: string
          weight: 0

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

    Algorithm string
    [string] Algorithm for the balancing.
    DatacenterId string
    [string] A Datacenter's UUID.
    ListenerIp string
    [string] Listening IP. (inbound)
    ListenerPort int
    [int] Listening port number. (inbound) (range: 1 to 65535)
    NetworkloadbalancerId string
    Protocol string
    [string] Protocol of the balancing.
    Targets List<Ionoscloud.ForwardingRuleTarget>
    [Set] Array of items in that collection.
    HealthCheck Ionoscloud.ForwardingRuleHealthCheck
    Health check attributes for Network Load Balancer forwarding rule.
    Name string
    [string] A name of that Network Load Balancer forwarding rule.
    Algorithm string
    [string] Algorithm for the balancing.
    DatacenterId string
    [string] A Datacenter's UUID.
    ListenerIp string
    [string] Listening IP. (inbound)
    ListenerPort int
    [int] Listening port number. (inbound) (range: 1 to 65535)
    NetworkloadbalancerId string
    Protocol string
    [string] Protocol of the balancing.
    Targets []ForwardingRuleTargetArgs
    [Set] Array of items in that collection.
    HealthCheck ForwardingRuleHealthCheckArgs
    Health check attributes for Network Load Balancer forwarding rule.
    Name string
    [string] A name of that Network Load Balancer forwarding rule.
    algorithm String
    [string] Algorithm for the balancing.
    datacenterId String
    [string] A Datacenter's UUID.
    listenerIp String
    [string] Listening IP. (inbound)
    listenerPort Integer
    [int] Listening port number. (inbound) (range: 1 to 65535)
    networkloadbalancerId String
    protocol String
    [string] Protocol of the balancing.
    targets List<ForwardingRuleTarget>
    [Set] Array of items in that collection.
    healthCheck ForwardingRuleHealthCheck
    Health check attributes for Network Load Balancer forwarding rule.
    name String
    [string] A name of that Network Load Balancer forwarding rule.
    algorithm string
    [string] Algorithm for the balancing.
    datacenterId string
    [string] A Datacenter's UUID.
    listenerIp string
    [string] Listening IP. (inbound)
    listenerPort number
    [int] Listening port number. (inbound) (range: 1 to 65535)
    networkloadbalancerId string
    protocol string
    [string] Protocol of the balancing.
    targets ForwardingRuleTarget[]
    [Set] Array of items in that collection.
    healthCheck ForwardingRuleHealthCheck
    Health check attributes for Network Load Balancer forwarding rule.
    name string
    [string] A name of that Network Load Balancer forwarding rule.
    algorithm str
    [string] Algorithm for the balancing.
    datacenter_id str
    [string] A Datacenter's UUID.
    listener_ip str
    [string] Listening IP. (inbound)
    listener_port int
    [int] Listening port number. (inbound) (range: 1 to 65535)
    networkloadbalancer_id str
    protocol str
    [string] Protocol of the balancing.
    targets Sequence[ForwardingRuleTargetArgs]
    [Set] Array of items in that collection.
    health_check ForwardingRuleHealthCheckArgs
    Health check attributes for Network Load Balancer forwarding rule.
    name str
    [string] A name of that Network Load Balancer forwarding rule.
    algorithm String
    [string] Algorithm for the balancing.
    datacenterId String
    [string] A Datacenter's UUID.
    listenerIp String
    [string] Listening IP. (inbound)
    listenerPort Number
    [int] Listening port number. (inbound) (range: 1 to 65535)
    networkloadbalancerId String
    protocol String
    [string] Protocol of the balancing.
    targets List<Property Map>
    [Set] Array of items in that collection.
    healthCheck Property Map
    Health check attributes for Network Load Balancer forwarding rule.
    name String
    [string] A name of that Network Load Balancer forwarding rule.

    Outputs

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

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

    Look up Existing ForwardingRule Resource

    Get an existing ForwardingRule 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?: ForwardingRuleState, opts?: CustomResourceOptions): ForwardingRule
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        algorithm: Optional[str] = None,
        datacenter_id: Optional[str] = None,
        health_check: Optional[ForwardingRuleHealthCheckArgs] = None,
        listener_ip: Optional[str] = None,
        listener_port: Optional[int] = None,
        name: Optional[str] = None,
        networkloadbalancer_id: Optional[str] = None,
        protocol: Optional[str] = None,
        targets: Optional[Sequence[ForwardingRuleTargetArgs]] = None) -> ForwardingRule
    func GetForwardingRule(ctx *Context, name string, id IDInput, state *ForwardingRuleState, opts ...ResourceOption) (*ForwardingRule, error)
    public static ForwardingRule Get(string name, Input<string> id, ForwardingRuleState? state, CustomResourceOptions? opts = null)
    public static ForwardingRule get(String name, Output<String> id, ForwardingRuleState state, CustomResourceOptions options)
    resources:  _:    type: ionoscloud:nlb:ForwardingRule    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
    [string] Algorithm for the balancing.
    DatacenterId string
    [string] A Datacenter's UUID.
    HealthCheck Ionoscloud.ForwardingRuleHealthCheck
    Health check attributes for Network Load Balancer forwarding rule.
    ListenerIp string
    [string] Listening IP. (inbound)
    ListenerPort int
    [int] Listening port number. (inbound) (range: 1 to 65535)
    Name string
    [string] A name of that Network Load Balancer forwarding rule.
    NetworkloadbalancerId string
    Protocol string
    [string] Protocol of the balancing.
    Targets List<Ionoscloud.ForwardingRuleTarget>
    [Set] Array of items in that collection.
    Algorithm string
    [string] Algorithm for the balancing.
    DatacenterId string
    [string] A Datacenter's UUID.
    HealthCheck ForwardingRuleHealthCheckArgs
    Health check attributes for Network Load Balancer forwarding rule.
    ListenerIp string
    [string] Listening IP. (inbound)
    ListenerPort int
    [int] Listening port number. (inbound) (range: 1 to 65535)
    Name string
    [string] A name of that Network Load Balancer forwarding rule.
    NetworkloadbalancerId string
    Protocol string
    [string] Protocol of the balancing.
    Targets []ForwardingRuleTargetArgs
    [Set] Array of items in that collection.
    algorithm String
    [string] Algorithm for the balancing.
    datacenterId String
    [string] A Datacenter's UUID.
    healthCheck ForwardingRuleHealthCheck
    Health check attributes for Network Load Balancer forwarding rule.
    listenerIp String
    [string] Listening IP. (inbound)
    listenerPort Integer
    [int] Listening port number. (inbound) (range: 1 to 65535)
    name String
    [string] A name of that Network Load Balancer forwarding rule.
    networkloadbalancerId String
    protocol String
    [string] Protocol of the balancing.
    targets List<ForwardingRuleTarget>
    [Set] Array of items in that collection.
    algorithm string
    [string] Algorithm for the balancing.
    datacenterId string
    [string] A Datacenter's UUID.
    healthCheck ForwardingRuleHealthCheck
    Health check attributes for Network Load Balancer forwarding rule.
    listenerIp string
    [string] Listening IP. (inbound)
    listenerPort number
    [int] Listening port number. (inbound) (range: 1 to 65535)
    name string
    [string] A name of that Network Load Balancer forwarding rule.
    networkloadbalancerId string
    protocol string
    [string] Protocol of the balancing.
    targets ForwardingRuleTarget[]
    [Set] Array of items in that collection.
    algorithm str
    [string] Algorithm for the balancing.
    datacenter_id str
    [string] A Datacenter's UUID.
    health_check ForwardingRuleHealthCheckArgs
    Health check attributes for Network Load Balancer forwarding rule.
    listener_ip str
    [string] Listening IP. (inbound)
    listener_port int
    [int] Listening port number. (inbound) (range: 1 to 65535)
    name str
    [string] A name of that Network Load Balancer forwarding rule.
    networkloadbalancer_id str
    protocol str
    [string] Protocol of the balancing.
    targets Sequence[ForwardingRuleTargetArgs]
    [Set] Array of items in that collection.
    algorithm String
    [string] Algorithm for the balancing.
    datacenterId String
    [string] A Datacenter's UUID.
    healthCheck Property Map
    Health check attributes for Network Load Balancer forwarding rule.
    listenerIp String
    [string] Listening IP. (inbound)
    listenerPort Number
    [int] Listening port number. (inbound) (range: 1 to 65535)
    name String
    [string] A name of that Network Load Balancer forwarding rule.
    networkloadbalancerId String
    protocol String
    [string] Protocol of the balancing.
    targets List<Property Map>
    [Set] Array of items in that collection.

    Supporting Types

    ForwardingRuleHealthCheck, ForwardingRuleHealthCheckArgs

    ClientTimeout int
    [int] ClientTimeout is expressed in milliseconds. This inactivity timeout applies when the client is expected to acknowledge or send data. If unset the default of 50 seconds will be used.
    ConnectTimeout int
    [int] It specifies the maximum time (in milliseconds) to wait for a connection attempt to a target VM to succeed. If unset, the default of 5 seconds will be used.
    Retries int
    [int] Retries specifies the number of retries to perform on a target VM after a connection failure. If unset, the default value of 3 will be used.
    TargetTimeout int
    [int] TargetTimeout specifies the maximum inactivity time (in milliseconds) on the target VM side. If unset, the default of 50 seconds will be used.
    ClientTimeout int
    [int] ClientTimeout is expressed in milliseconds. This inactivity timeout applies when the client is expected to acknowledge or send data. If unset the default of 50 seconds will be used.
    ConnectTimeout int
    [int] It specifies the maximum time (in milliseconds) to wait for a connection attempt to a target VM to succeed. If unset, the default of 5 seconds will be used.
    Retries int
    [int] Retries specifies the number of retries to perform on a target VM after a connection failure. If unset, the default value of 3 will be used.
    TargetTimeout int
    [int] TargetTimeout specifies the maximum inactivity time (in milliseconds) on the target VM side. If unset, the default of 50 seconds will be used.
    clientTimeout Integer
    [int] ClientTimeout is expressed in milliseconds. This inactivity timeout applies when the client is expected to acknowledge or send data. If unset the default of 50 seconds will be used.
    connectTimeout Integer
    [int] It specifies the maximum time (in milliseconds) to wait for a connection attempt to a target VM to succeed. If unset, the default of 5 seconds will be used.
    retries Integer
    [int] Retries specifies the number of retries to perform on a target VM after a connection failure. If unset, the default value of 3 will be used.
    targetTimeout Integer
    [int] TargetTimeout specifies the maximum inactivity time (in milliseconds) on the target VM side. If unset, the default of 50 seconds will be used.
    clientTimeout number
    [int] ClientTimeout is expressed in milliseconds. This inactivity timeout applies when the client is expected to acknowledge or send data. If unset the default of 50 seconds will be used.
    connectTimeout number
    [int] It specifies the maximum time (in milliseconds) to wait for a connection attempt to a target VM to succeed. If unset, the default of 5 seconds will be used.
    retries number
    [int] Retries specifies the number of retries to perform on a target VM after a connection failure. If unset, the default value of 3 will be used.
    targetTimeout number
    [int] TargetTimeout specifies the maximum inactivity time (in milliseconds) on the target VM side. If unset, the default of 50 seconds will be used.
    client_timeout int
    [int] ClientTimeout is expressed in milliseconds. This inactivity timeout applies when the client is expected to acknowledge or send data. If unset the default of 50 seconds will be used.
    connect_timeout int
    [int] It specifies the maximum time (in milliseconds) to wait for a connection attempt to a target VM to succeed. If unset, the default of 5 seconds will be used.
    retries int
    [int] Retries specifies the number of retries to perform on a target VM after a connection failure. If unset, the default value of 3 will be used.
    target_timeout int
    [int] TargetTimeout specifies the maximum inactivity time (in milliseconds) on the target VM side. If unset, the default of 50 seconds will be used.
    clientTimeout Number
    [int] ClientTimeout is expressed in milliseconds. This inactivity timeout applies when the client is expected to acknowledge or send data. If unset the default of 50 seconds will be used.
    connectTimeout Number
    [int] It specifies the maximum time (in milliseconds) to wait for a connection attempt to a target VM to succeed. If unset, the default of 5 seconds will be used.
    retries Number
    [int] Retries specifies the number of retries to perform on a target VM after a connection failure. If unset, the default value of 3 will be used.
    targetTimeout Number
    [int] TargetTimeout specifies the maximum inactivity time (in milliseconds) on the target VM side. If unset, the default of 50 seconds will be used.

    ForwardingRuleTarget, ForwardingRuleTargetArgs

    Ip string
    [string] IP of a balanced target VM.
    Port int
    [int] Port of the balanced target service. (range: 1 to 65535).
    Weight int
    [int] Weight parameter is used to adjust the target VM's weight relative to other target VMs.
    HealthCheck Ionoscloud.ForwardingRuleTargetHealthCheck
    Health check attributes for Network Load Balancer forwarding rule target.
    ProxyProtocol string
    [string] The proxy protocol version. Accepted values are none, v1, v2, v2ssl. If unspecified, the default value of none is used.
    Ip string
    [string] IP of a balanced target VM.
    Port int
    [int] Port of the balanced target service. (range: 1 to 65535).
    Weight int
    [int] Weight parameter is used to adjust the target VM's weight relative to other target VMs.
    HealthCheck ForwardingRuleTargetHealthCheck
    Health check attributes for Network Load Balancer forwarding rule target.
    ProxyProtocol string
    [string] The proxy protocol version. Accepted values are none, v1, v2, v2ssl. If unspecified, the default value of none is used.
    ip String
    [string] IP of a balanced target VM.
    port Integer
    [int] Port of the balanced target service. (range: 1 to 65535).
    weight Integer
    [int] Weight parameter is used to adjust the target VM's weight relative to other target VMs.
    healthCheck ForwardingRuleTargetHealthCheck
    Health check attributes for Network Load Balancer forwarding rule target.
    proxyProtocol String
    [string] The proxy protocol version. Accepted values are none, v1, v2, v2ssl. If unspecified, the default value of none is used.
    ip string
    [string] IP of a balanced target VM.
    port number
    [int] Port of the balanced target service. (range: 1 to 65535).
    weight number
    [int] Weight parameter is used to adjust the target VM's weight relative to other target VMs.
    healthCheck ForwardingRuleTargetHealthCheck
    Health check attributes for Network Load Balancer forwarding rule target.
    proxyProtocol string
    [string] The proxy protocol version. Accepted values are none, v1, v2, v2ssl. If unspecified, the default value of none is used.
    ip str
    [string] IP of a balanced target VM.
    port int
    [int] Port of the balanced target service. (range: 1 to 65535).
    weight int
    [int] Weight parameter is used to adjust the target VM's weight relative to other target VMs.
    health_check ForwardingRuleTargetHealthCheck
    Health check attributes for Network Load Balancer forwarding rule target.
    proxy_protocol str
    [string] The proxy protocol version. Accepted values are none, v1, v2, v2ssl. If unspecified, the default value of none is used.
    ip String
    [string] IP of a balanced target VM.
    port Number
    [int] Port of the balanced target service. (range: 1 to 65535).
    weight Number
    [int] Weight parameter is used to adjust the target VM's weight relative to other target VMs.
    healthCheck Property Map
    Health check attributes for Network Load Balancer forwarding rule target.
    proxyProtocol String
    [string] The proxy protocol version. Accepted values are none, v1, v2, v2ssl. If unspecified, the default value of none is used.

    ForwardingRuleTargetHealthCheck, ForwardingRuleTargetHealthCheckArgs

    Check bool
    [boolean] Check specifies whether the target VM's health is checked.
    CheckInterval int
    [int] CheckInterval determines the duration (in milliseconds) between consecutive health checks. If unspecified a default of 2000 ms is used.
    Maintenance bool
    [boolean] Maintenance specifies if a target VM should be marked as down, even if it is not.
    Check bool
    [boolean] Check specifies whether the target VM's health is checked.
    CheckInterval int
    [int] CheckInterval determines the duration (in milliseconds) between consecutive health checks. If unspecified a default of 2000 ms is used.
    Maintenance bool
    [boolean] Maintenance specifies if a target VM should be marked as down, even if it is not.
    check Boolean
    [boolean] Check specifies whether the target VM's health is checked.
    checkInterval Integer
    [int] CheckInterval determines the duration (in milliseconds) between consecutive health checks. If unspecified a default of 2000 ms is used.
    maintenance Boolean
    [boolean] Maintenance specifies if a target VM should be marked as down, even if it is not.
    check boolean
    [boolean] Check specifies whether the target VM's health is checked.
    checkInterval number
    [int] CheckInterval determines the duration (in milliseconds) between consecutive health checks. If unspecified a default of 2000 ms is used.
    maintenance boolean
    [boolean] Maintenance specifies if a target VM should be marked as down, even if it is not.
    check bool
    [boolean] Check specifies whether the target VM's health is checked.
    check_interval int
    [int] CheckInterval determines the duration (in milliseconds) between consecutive health checks. If unspecified a default of 2000 ms is used.
    maintenance bool
    [boolean] Maintenance specifies if a target VM should be marked as down, even if it is not.
    check Boolean
    [boolean] Check specifies whether the target VM's health is checked.
    checkInterval Number
    [int] CheckInterval determines the duration (in milliseconds) between consecutive health checks. If unspecified a default of 2000 ms is used.
    maintenance Boolean
    [boolean] Maintenance specifies if a target VM should be marked as down, even if it is not.

    Import

    A Network Load Balancer Forwarding Rule resource can be imported using its resource id, the datacenter id and the networkloadbalancer id e.g.

    $ pulumi import ionoscloud:nlb/forwardingRule:ForwardingRule my_networkloadbalancer_forwardingrule datacenter uuid/networkloadbalancer uuid/networkloadbalancer_forwardingrule uuid

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

    Package Details

    Repository
    ionoscloud ionos-cloud/pulumi-ionoscloud
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the ionoscloud Terraform Provider.
    ionoscloud logo
    IonosCloud v0.2.3 published on Tuesday, May 13, 2025 by ionos-cloud
    ionos-cloud/pulumi-ionoscloud