Docs Home Pulumi IaC Pulumi ESC Pulumi Insights Pulumi Cloud Packages Tutorials
  1. Packages
  2. Ionoscloud Provider
  3. API Docs
  4. NetworkloadbalancerForwardingrule
ionoscloud 6.7.6 published on Monday, Apr 14, 2025 by ionos-cloud
ionos-cloud/terraform-provider-ionoscloud

ionoscloud.NetworkloadbalancerForwardingrule

Explore with Pulumi AI

ionoscloud logo
ionoscloud 6.7.6 published on Monday, Apr 14, 2025 by ionos-cloud
ionos-cloud/terraform-provider-ionoscloud

    Manages a Network Load Balancer Forwarding Rule on IonosCloud.

    Example Usage

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

const exampleDatacenter = new ionoscloud.Datacenter("exampleDatacenter", {
    location: "us/las",
    description: "Datacenter Description",
    secAuthProtection: false,
});
const example1 = new ionoscloud.Lan("example1", {
    datacenterId: exampleDatacenter.datacenterId,
    "public": false,
});
const example2 = new ionoscloud.Lan("example2", {
    datacenterId: exampleDatacenter.datacenterId,
    "public": false,
});
const exampleNetworkloadbalancer = new ionoscloud.Networkloadbalancer("exampleNetworkloadbalancer", {
    datacenterId: exampleDatacenter.datacenterId,
    listenerLan: example1.lanId,
    targetLan: example2.lanId,
    ips: ["10.12.118.224"],
    lbPrivateIps: ["10.13.72.225/24"],
});
const exampleNetworkloadbalancerForwardingrule = new ionoscloud.NetworkloadbalancerForwardingrule("exampleNetworkloadbalancerForwardingrule", {
    datacenterId: exampleDatacenter.datacenterId,
    networkloadbalancerId: exampleNetworkloadbalancer.networkloadbalancerId,
    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_datacenter = ionoscloud.Datacenter("exampleDatacenter",
    location="us/las",
    description="Datacenter Description",
    sec_auth_protection=False)
example1 = ionoscloud.Lan("example1",
    datacenter_id=example_datacenter.datacenter_id,
    public=False)
example2 = ionoscloud.Lan("example2",
    datacenter_id=example_datacenter.datacenter_id,
    public=False)
example_networkloadbalancer = ionoscloud.Networkloadbalancer("exampleNetworkloadbalancer",
    datacenter_id=example_datacenter.datacenter_id,
    listener_lan=example1.lan_id,
    target_lan=example2.lan_id,
    ips=["10.12.118.224"],
    lb_private_ips=["10.13.72.225/24"])
example_networkloadbalancer_forwardingrule = ionoscloud.NetworkloadbalancerForwardingrule("exampleNetworkloadbalancerForwardingrule",
    datacenter_id=example_datacenter.datacenter_id,
    networkloadbalancer_id=example_networkloadbalancer.networkloadbalancer_id,
    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/pulumi/pulumi-terraform-provider/sdks/go/ionoscloud/v6/ionoscloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleDatacenter, err := ionoscloud.NewDatacenter(ctx, "exampleDatacenter", &ionoscloud.DatacenterArgs{
			Location:          pulumi.String("us/las"),
			Description:       pulumi.String("Datacenter Description"),
			SecAuthProtection: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		example1, err := ionoscloud.NewLan(ctx, "example1", &ionoscloud.LanArgs{
			DatacenterId: exampleDatacenter.DatacenterId,
			Public:       pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		example2, err := ionoscloud.NewLan(ctx, "example2", &ionoscloud.LanArgs{
			DatacenterId: exampleDatacenter.DatacenterId,
			Public:       pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		exampleNetworkloadbalancer, err := ionoscloud.NewNetworkloadbalancer(ctx, "exampleNetworkloadbalancer", &ionoscloud.NetworkloadbalancerArgs{
			DatacenterId: exampleDatacenter.DatacenterId,
			ListenerLan:  example1.LanId,
			TargetLan:    example2.LanId,
			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 = ionoscloud.NewNetworkloadbalancerForwardingrule(ctx, "exampleNetworkloadbalancerForwardingrule", &ionoscloud.NetworkloadbalancerForwardingruleArgs{
			DatacenterId:          exampleDatacenter.DatacenterId,
			NetworkloadbalancerId: exampleNetworkloadbalancer.NetworkloadbalancerId,
			Algorithm:             pulumi.String("SOURCE_IP"),
			Protocol:              pulumi.String("TCP"),
			ListenerIp:            pulumi.String("10.12.118.224"),
			ListenerPort:          pulumi.Float64(8081),
			Targets: ionoscloud.NetworkloadbalancerForwardingruleTargetArray{
				&ionoscloud.NetworkloadbalancerForwardingruleTargetArgs{
					Ip:            pulumi.String("22.231.2.2"),
					Port:          pulumi.Float64(8080),
					Weight:        pulumi.Float64(123),
					ProxyProtocol: pulumi.String("v1"),
					HealthCheck: &ionoscloud.NetworkloadbalancerForwardingruleTargetHealthCheckArgs{
						Check:         pulumi.Bool(true),
						CheckInterval: pulumi.Float64(1000),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

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

    var example1 = new Ionoscloud.Lan("example1", new()
    {
        DatacenterId = exampleDatacenter.DatacenterId,
        Public = false,
    });

    var example2 = new Ionoscloud.Lan("example2", new()
    {
        DatacenterId = exampleDatacenter.DatacenterId,
        Public = false,
    });

    var exampleNetworkloadbalancer = new Ionoscloud.Networkloadbalancer("exampleNetworkloadbalancer", new()
    {
        DatacenterId = exampleDatacenter.DatacenterId,
        ListenerLan = example1.LanId,
        TargetLan = example2.LanId,
        Ips = new[]
        {
            "10.12.118.224",
        },
        LbPrivateIps = new[]
        {
            "10.13.72.225/24",
        },
    });

    var exampleNetworkloadbalancerForwardingrule = new Ionoscloud.NetworkloadbalancerForwardingrule("exampleNetworkloadbalancerForwardingrule", new()
    {
        DatacenterId = exampleDatacenter.DatacenterId,
        NetworkloadbalancerId = exampleNetworkloadbalancer.NetworkloadbalancerId,
        Algorithm = "SOURCE_IP",
        Protocol = "TCP",
        ListenerIp = "10.12.118.224",
        ListenerPort = 8081,
        Targets = new[]
        {
            new Ionoscloud.Inputs.NetworkloadbalancerForwardingruleTargetArgs
            {
                Ip = "22.231.2.2",
                Port = 8080,
                Weight = 123,
                ProxyProtocol = "v1",
                HealthCheck = new Ionoscloud.Inputs.NetworkloadbalancerForwardingruleTargetHealthCheckArgs
                {
                    Check = true,
                    CheckInterval = 1000,
                },
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.ionoscloud.Datacenter;
import com.pulumi.ionoscloud.DatacenterArgs;
import com.pulumi.ionoscloud.Lan;
import com.pulumi.ionoscloud.LanArgs;
import com.pulumi.ionoscloud.Networkloadbalancer;
import com.pulumi.ionoscloud.NetworkloadbalancerArgs;
import com.pulumi.ionoscloud.NetworkloadbalancerForwardingrule;
import com.pulumi.ionoscloud.NetworkloadbalancerForwardingruleArgs;
import com.pulumi.ionoscloud.inputs.NetworkloadbalancerForwardingruleTargetArgs;
import com.pulumi.ionoscloud.inputs.NetworkloadbalancerForwardingruleTargetHealthCheckArgs;
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 exampleDatacenter = new Datacenter("exampleDatacenter", DatacenterArgs.builder()
            .location("us/las")
            .description("Datacenter Description")
            .secAuthProtection(false)
            .build());

        var example1 = new Lan("example1", LanArgs.builder()
            .datacenterId(exampleDatacenter.datacenterId())
            .public_(false)
            .build());

        var example2 = new Lan("example2", LanArgs.builder()
            .datacenterId(exampleDatacenter.datacenterId())
            .public_(false)
            .build());

        var exampleNetworkloadbalancer = new Networkloadbalancer("exampleNetworkloadbalancer", NetworkloadbalancerArgs.builder()
            .datacenterId(exampleDatacenter.datacenterId())
            .listenerLan(example1.lanId())
            .targetLan(example2.lanId())
            .ips("10.12.118.224")
            .lbPrivateIps("10.13.72.225/24")
            .build());

        var exampleNetworkloadbalancerForwardingrule = new NetworkloadbalancerForwardingrule("exampleNetworkloadbalancerForwardingrule", NetworkloadbalancerForwardingruleArgs.builder()
            .datacenterId(exampleDatacenter.datacenterId())
            .networkloadbalancerId(exampleNetworkloadbalancer.networkloadbalancerId())
            .algorithm("SOURCE_IP")
            .protocol("TCP")
            .listenerIp("10.12.118.224")
            .listenerPort("8081")
            .targets(NetworkloadbalancerForwardingruleTargetArgs.builder()
                .ip("22.231.2.2")
                .port("8080")
                .weight("123")
                .proxyProtocol("v1")
                .healthCheck(NetworkloadbalancerForwardingruleTargetHealthCheckArgs.builder()
                    .check(true)
                    .checkInterval(1000)
                    .build())
                .build())
            .build());

    }
}

    resources:
  exampleDatacenter:
    type: ionoscloud:Datacenter
    properties:
      location: us/las
      description: Datacenter Description
      secAuthProtection: false
  example1:
    type: ionoscloud:Lan
    properties:
      datacenterId: ${exampleDatacenter.datacenterId}
      public: false
  example2:
    type: ionoscloud:Lan
    properties:
      datacenterId: ${exampleDatacenter.datacenterId}
      public: false
  exampleNetworkloadbalancer:
    type: ionoscloud:Networkloadbalancer
    properties:
      datacenterId: ${exampleDatacenter.datacenterId}
      listenerLan: ${example1.lanId}
      targetLan: ${example2.lanId}
      ips:
        - 10.12.118.224
      lbPrivateIps:
        - 10.13.72.225/24
  exampleNetworkloadbalancerForwardingrule:
    type: ionoscloud:NetworkloadbalancerForwardingrule
    properties:
      datacenterId: ${exampleDatacenter.datacenterId}
      networkloadbalancerId: ${exampleNetworkloadbalancer.networkloadbalancerId}
      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

    Usage with dynamic block for targets:

    Coming soon!

    Coming soon!

    Coming soon!

    Coming soon!

    Coming soon!

    configuration:
  iPs:
    type: dynamic
    default:
      - 22.231.2.2
      - 22.231.2.3
      - 22.231.2.4
resources:
  exampleDatacenter:
    type: ionoscloud:Datacenter
    properties:
      location: us/las
      description: Datacenter Description
      secAuthProtection: false
  example1:
    type: ionoscloud:Lan
    properties:
      datacenterId: ${exampleDatacenter.datacenterId}
      public: false
  example2:
    type: ionoscloud:Lan
    properties:
      datacenterId: ${exampleDatacenter.datacenterId}
      public: false
  exampleNetworkloadbalancer:
    type: ionoscloud:Networkloadbalancer
    properties:
      datacenterId: ${exampleDatacenter.datacenterId}
      listenerLan: ${example1.lanId}
      targetLan: ${example2.lanId}
      ips:
        - 10.12.118.224
      lbPrivateIps:
        - 10.13.72.225/24
  exampleNetworkloadbalancerForwardingrule:
    type: ionoscloud:NetworkloadbalancerForwardingrule
    properties:
      datacenterId: ${exampleDatacenter.datacenterId}
      networkloadbalancerId: ${exampleNetworkloadbalancer.networkloadbalancerId}
      algorithm: SOURCE_IP
      protocol: TCP
      listenerIp: 10.12.118.224
      listenerPort: '8081'
      dynamic:
        - forEach: ${iPs}
          content:
            - ip: ${targets.value}
              port: '31234'
              weight: '1'
              healthCheck:
                - check: true
                  checkInterval: 1000
                  maintenance: false

    Create NetworkloadbalancerForwardingrule Resource

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

    Constructor syntax

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

@overload
def NetworkloadbalancerForwardingrule(resource_name: str,
                                      opts: Optional[ResourceOptions] = None,
                                      algorithm: Optional[str] = None,
                                      datacenter_id: Optional[str] = None,
                                      listener_ip: Optional[str] = None,
                                      listener_port: Optional[float] = None,
                                      networkloadbalancer_id: Optional[str] = None,
                                      protocol: Optional[str] = None,
                                      targets: Optional[Sequence[NetworkloadbalancerForwardingruleTargetArgs]] = None,
                                      health_check: Optional[NetworkloadbalancerForwardingruleHealthCheckArgs] = None,
                                      name: Optional[str] = None,
                                      networkloadbalancer_forwardingrule_id: Optional[str] = None,
                                      timeouts: Optional[NetworkloadbalancerForwardingruleTimeoutsArgs] = None)
    func NewNetworkloadbalancerForwardingrule(ctx *Context, name string, args NetworkloadbalancerForwardingruleArgs, opts ...ResourceOption) (*NetworkloadbalancerForwardingrule, error)
    public NetworkloadbalancerForwardingrule(string name, NetworkloadbalancerForwardingruleArgs args, CustomResourceOptions? opts = null)
    public NetworkloadbalancerForwardingrule(String name, NetworkloadbalancerForwardingruleArgs args)
public NetworkloadbalancerForwardingrule(String name, NetworkloadbalancerForwardingruleArgs args, CustomResourceOptions options)

    type: ionoscloud:NetworkloadbalancerForwardingrule
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 NetworkloadbalancerForwardingruleArgs
    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 NetworkloadbalancerForwardingruleArgs
    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 NetworkloadbalancerForwardingruleArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args NetworkloadbalancerForwardingruleArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args NetworkloadbalancerForwardingruleArgs
    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 networkloadbalancerForwardingruleResource = new Ionoscloud.NetworkloadbalancerForwardingrule("networkloadbalancerForwardingruleResource", new()
{
    Algorithm = "string",
    DatacenterId = "string",
    ListenerIp = "string",
    ListenerPort = 0,
    NetworkloadbalancerId = "string",
    Protocol = "string",
    Targets = new[]
    {
        new Ionoscloud.Inputs.NetworkloadbalancerForwardingruleTargetArgs
        {
            Ip = "string",
            Port = 0,
            Weight = 0,
            HealthCheck = new Ionoscloud.Inputs.NetworkloadbalancerForwardingruleTargetHealthCheckArgs
            {
                Check = false,
                CheckInterval = 0,
                Maintenance = false,
            },
            ProxyProtocol = "string",
        },
    },
    HealthCheck = new Ionoscloud.Inputs.NetworkloadbalancerForwardingruleHealthCheckArgs
    {
        ClientTimeout = 0,
        ConnectTimeout = 0,
        Retries = 0,
        TargetTimeout = 0,
    },
    Name = "string",
    NetworkloadbalancerForwardingruleId = "string",
    Timeouts = new Ionoscloud.Inputs.NetworkloadbalancerForwardingruleTimeoutsArgs
    {
        Create = "string",
        Default = "string",
        Delete = "string",
        Update = "string",
    },
});

    example, err := ionoscloud.NewNetworkloadbalancerForwardingrule(ctx, "networkloadbalancerForwardingruleResource", &ionoscloud.NetworkloadbalancerForwardingruleArgs{
	Algorithm:             pulumi.String("string"),
	DatacenterId:          pulumi.String("string"),
	ListenerIp:            pulumi.String("string"),
	ListenerPort:          pulumi.Float64(0),
	NetworkloadbalancerId: pulumi.String("string"),
	Protocol:              pulumi.String("string"),
	Targets: ionoscloud.NetworkloadbalancerForwardingruleTargetArray{
		&ionoscloud.NetworkloadbalancerForwardingruleTargetArgs{
			Ip:     pulumi.String("string"),
			Port:   pulumi.Float64(0),
			Weight: pulumi.Float64(0),
			HealthCheck: &ionoscloud.NetworkloadbalancerForwardingruleTargetHealthCheckArgs{
				Check:         pulumi.Bool(false),
				CheckInterval: pulumi.Float64(0),
				Maintenance:   pulumi.Bool(false),
			},
			ProxyProtocol: pulumi.String("string"),
		},
	},
	HealthCheck: &ionoscloud.NetworkloadbalancerForwardingruleHealthCheckArgs{
		ClientTimeout:  pulumi.Float64(0),
		ConnectTimeout: pulumi.Float64(0),
		Retries:        pulumi.Float64(0),
		TargetTimeout:  pulumi.Float64(0),
	},
	Name:                                pulumi.String("string"),
	NetworkloadbalancerForwardingruleId: pulumi.String("string"),
	Timeouts: &ionoscloud.NetworkloadbalancerForwardingruleTimeoutsArgs{
		Create:  pulumi.String("string"),
		Default: pulumi.String("string"),
		Delete:  pulumi.String("string"),
		Update:  pulumi.String("string"),
	},
})

    var networkloadbalancerForwardingruleResource = new NetworkloadbalancerForwardingrule("networkloadbalancerForwardingruleResource", NetworkloadbalancerForwardingruleArgs.builder()
    .algorithm("string")
    .datacenterId("string")
    .listenerIp("string")
    .listenerPort(0)
    .networkloadbalancerId("string")
    .protocol("string")
    .targets(NetworkloadbalancerForwardingruleTargetArgs.builder()
        .ip("string")
        .port(0)
        .weight(0)
        .healthCheck(NetworkloadbalancerForwardingruleTargetHealthCheckArgs.builder()
            .check(false)
            .checkInterval(0)
            .maintenance(false)
            .build())
        .proxyProtocol("string")
        .build())
    .healthCheck(NetworkloadbalancerForwardingruleHealthCheckArgs.builder()
        .clientTimeout(0)
        .connectTimeout(0)
        .retries(0)
        .targetTimeout(0)
        .build())
    .name("string")
    .networkloadbalancerForwardingruleId("string")
    .timeouts(NetworkloadbalancerForwardingruleTimeoutsArgs.builder()
        .create("string")
        .default_("string")
        .delete("string")
        .update("string")
        .build())
    .build());

    networkloadbalancer_forwardingrule_resource = ionoscloud.NetworkloadbalancerForwardingrule("networkloadbalancerForwardingruleResource",
    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",
    networkloadbalancer_forwardingrule_id="string",
    timeouts={
        "create": "string",
        "default": "string",
        "delete": "string",
        "update": "string",
    })

    const networkloadbalancerForwardingruleResource = new ionoscloud.NetworkloadbalancerForwardingrule("networkloadbalancerForwardingruleResource", {
    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",
    networkloadbalancerForwardingruleId: "string",
    timeouts: {
        create: "string",
        "default": "string",
        "delete": "string",
        update: "string",
    },
});

    type: ionoscloud:NetworkloadbalancerForwardingrule
properties:
    algorithm: string
    datacenterId: string
    healthCheck:
        clientTimeout: 0
        connectTimeout: 0
        retries: 0
        targetTimeout: 0
    listenerIp: string
    listenerPort: 0
    name: string
    networkloadbalancerForwardingruleId: string
    networkloadbalancerId: string
    protocol: string
    targets:
        - healthCheck:
            check: false
            checkInterval: 0
            maintenance: false
          ip: string
          port: 0
          proxyProtocol: string
          weight: 0
    timeouts:
        create: string
        default: string
        delete: string
        update: string

    NetworkloadbalancerForwardingrule 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 NetworkloadbalancerForwardingrule 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 double
    [int] Listening port number. (inbound) (range: 1 to 65535)
    NetworkloadbalancerId string
    Protocol string
    [string] Protocol of the balancing.
    Targets List<NetworkloadbalancerForwardingruleTarget>
    [Set] Array of items in that collection.
    HealthCheck NetworkloadbalancerForwardingruleHealthCheck
    Health check attributes for Network Load Balancer forwarding rule.
    Name string
    [string] A name of that Network Load Balancer forwarding rule.
    NetworkloadbalancerForwardingruleId string
    Timeouts NetworkloadbalancerForwardingruleTimeouts
    Algorithm string
    [string] Algorithm for the balancing.
    DatacenterId string
    [string] A Datacenter's UUID.
    ListenerIp string
    [string] Listening IP. (inbound)
    ListenerPort float64
    [int] Listening port number. (inbound) (range: 1 to 65535)
    NetworkloadbalancerId string
    Protocol string
    [string] Protocol of the balancing.
    Targets []NetworkloadbalancerForwardingruleTargetArgs
    [Set] Array of items in that collection.
    HealthCheck NetworkloadbalancerForwardingruleHealthCheckArgs
    Health check attributes for Network Load Balancer forwarding rule.
    Name string
    [string] A name of that Network Load Balancer forwarding rule.
    NetworkloadbalancerForwardingruleId string
    Timeouts NetworkloadbalancerForwardingruleTimeoutsArgs
    algorithm String
    [string] Algorithm for the balancing.
    datacenterId String
    [string] A Datacenter's UUID.
    listenerIp String
    [string] Listening IP. (inbound)
    listenerPort Double
    [int] Listening port number. (inbound) (range: 1 to 65535)
    networkloadbalancerId String
    protocol String
    [string] Protocol of the balancing.
    targets List<NetworkloadbalancerForwardingruleTarget>
    [Set] Array of items in that collection.
    healthCheck NetworkloadbalancerForwardingruleHealthCheck
    Health check attributes for Network Load Balancer forwarding rule.
    name String
    [string] A name of that Network Load Balancer forwarding rule.
    networkloadbalancerForwardingruleId String
    timeouts NetworkloadbalancerForwardingruleTimeouts
    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 NetworkloadbalancerForwardingruleTarget[]
    [Set] Array of items in that collection.
    healthCheck NetworkloadbalancerForwardingruleHealthCheck
    Health check attributes for Network Load Balancer forwarding rule.
    name string
    [string] A name of that Network Load Balancer forwarding rule.
    networkloadbalancerForwardingruleId string
    timeouts NetworkloadbalancerForwardingruleTimeouts
    algorithm str
    [string] Algorithm for the balancing.
    datacenter_id str
    [string] A Datacenter's UUID.
    listener_ip str
    [string] Listening IP. (inbound)
    listener_port float
    [int] Listening port number. (inbound) (range: 1 to 65535)
    networkloadbalancer_id str
    protocol str
    [string] Protocol of the balancing.
    targets Sequence[NetworkloadbalancerForwardingruleTargetArgs]
    [Set] Array of items in that collection.
    health_check NetworkloadbalancerForwardingruleHealthCheckArgs
    Health check attributes for Network Load Balancer forwarding rule.
    name str
    [string] A name of that Network Load Balancer forwarding rule.
    networkloadbalancer_forwardingrule_id str
    timeouts NetworkloadbalancerForwardingruleTimeoutsArgs
    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.
    networkloadbalancerForwardingruleId String
    timeouts Property Map

    Outputs

    All input properties are implicitly available as output properties. Additionally, the NetworkloadbalancerForwardingrule 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 NetworkloadbalancerForwardingrule Resource

    Get an existing NetworkloadbalancerForwardingrule 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?: NetworkloadbalancerForwardingruleState, opts?: CustomResourceOptions): NetworkloadbalancerForwardingrule
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        algorithm: Optional[str] = None,
        datacenter_id: Optional[str] = None,
        health_check: Optional[NetworkloadbalancerForwardingruleHealthCheckArgs] = None,
        listener_ip: Optional[str] = None,
        listener_port: Optional[float] = None,
        name: Optional[str] = None,
        networkloadbalancer_forwardingrule_id: Optional[str] = None,
        networkloadbalancer_id: Optional[str] = None,
        protocol: Optional[str] = None,
        targets: Optional[Sequence[NetworkloadbalancerForwardingruleTargetArgs]] = None,
        timeouts: Optional[NetworkloadbalancerForwardingruleTimeoutsArgs] = None) -> NetworkloadbalancerForwardingrule
    func GetNetworkloadbalancerForwardingrule(ctx *Context, name string, id IDInput, state *NetworkloadbalancerForwardingruleState, opts ...ResourceOption) (*NetworkloadbalancerForwardingrule, error)
    public static NetworkloadbalancerForwardingrule Get(string name, Input<string> id, NetworkloadbalancerForwardingruleState? state, CustomResourceOptions? opts = null)
    public static NetworkloadbalancerForwardingrule get(String name, Output<String> id, NetworkloadbalancerForwardingruleState state, CustomResourceOptions options)
    resources:  _:    type: ionoscloud:NetworkloadbalancerForwardingrule    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 NetworkloadbalancerForwardingruleHealthCheck
    Health check attributes for Network Load Balancer forwarding rule.
    ListenerIp string
    [string] Listening IP. (inbound)
    ListenerPort double
    [int] Listening port number. (inbound) (range: 1 to 65535)
    Name string
    [string] A name of that Network Load Balancer forwarding rule.
    NetworkloadbalancerForwardingruleId string
    NetworkloadbalancerId string
    Protocol string
    [string] Protocol of the balancing.
    Targets List<NetworkloadbalancerForwardingruleTarget>
    [Set] Array of items in that collection.
    Timeouts NetworkloadbalancerForwardingruleTimeouts
    Algorithm string
    [string] Algorithm for the balancing.
    DatacenterId string
    [string] A Datacenter's UUID.
    HealthCheck NetworkloadbalancerForwardingruleHealthCheckArgs
    Health check attributes for Network Load Balancer forwarding rule.
    ListenerIp string
    [string] Listening IP. (inbound)
    ListenerPort float64
    [int] Listening port number. (inbound) (range: 1 to 65535)
    Name string
    [string] A name of that Network Load Balancer forwarding rule.
    NetworkloadbalancerForwardingruleId string
    NetworkloadbalancerId string
    Protocol string
    [string] Protocol of the balancing.
    Targets []NetworkloadbalancerForwardingruleTargetArgs
    [Set] Array of items in that collection.
    Timeouts NetworkloadbalancerForwardingruleTimeoutsArgs
    algorithm String
    [string] Algorithm for the balancing.
    datacenterId String
    [string] A Datacenter's UUID.
    healthCheck NetworkloadbalancerForwardingruleHealthCheck
    Health check attributes for Network Load Balancer forwarding rule.
    listenerIp String
    [string] Listening IP. (inbound)
    listenerPort Double
    [int] Listening port number. (inbound) (range: 1 to 65535)
    name String
    [string] A name of that Network Load Balancer forwarding rule.
    networkloadbalancerForwardingruleId String
    networkloadbalancerId String
    protocol String
    [string] Protocol of the balancing.
    targets List<NetworkloadbalancerForwardingruleTarget>
    [Set] Array of items in that collection.
    timeouts NetworkloadbalancerForwardingruleTimeouts
    algorithm string
    [string] Algorithm for the balancing.
    datacenterId string
    [string] A Datacenter's UUID.
    healthCheck NetworkloadbalancerForwardingruleHealthCheck
    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.
    networkloadbalancerForwardingruleId string
    networkloadbalancerId string
    protocol string
    [string] Protocol of the balancing.
    targets NetworkloadbalancerForwardingruleTarget[]
    [Set] Array of items in that collection.
    timeouts NetworkloadbalancerForwardingruleTimeouts
    algorithm str
    [string] Algorithm for the balancing.
    datacenter_id str
    [string] A Datacenter's UUID.
    health_check NetworkloadbalancerForwardingruleHealthCheckArgs
    Health check attributes for Network Load Balancer forwarding rule.
    listener_ip str
    [string] Listening IP. (inbound)
    listener_port float
    [int] Listening port number. (inbound) (range: 1 to 65535)
    name str
    [string] A name of that Network Load Balancer forwarding rule.
    networkloadbalancer_forwardingrule_id str
    networkloadbalancer_id str
    protocol str
    [string] Protocol of the balancing.
    targets Sequence[NetworkloadbalancerForwardingruleTargetArgs]
    [Set] Array of items in that collection.
    timeouts NetworkloadbalancerForwardingruleTimeoutsArgs
    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.
    networkloadbalancerForwardingruleId String
    networkloadbalancerId String
    protocol String
    [string] Protocol of the balancing.
    targets List<Property Map>
    [Set] Array of items in that collection.
    timeouts Property Map

    Supporting Types

    NetworkloadbalancerForwardingruleHealthCheck, NetworkloadbalancerForwardingruleHealthCheckArgs

    ClientTimeout double
    [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 double
    [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 double
    [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 double
    [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 float64
    [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 float64
    [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 float64
    [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 float64
    [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 Double
    [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 Double
    [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 Double
    [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 Double
    [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 float
    [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 float
    [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 float
    [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 float
    [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.

    NetworkloadbalancerForwardingruleTarget, NetworkloadbalancerForwardingruleTargetArgs

    Ip string
    [string] IP of a balanced target VM.
    Port double
    [int] Port of the balanced target service. (range: 1 to 65535).
    Weight double
    [int] Weight parameter is used to adjust the target VM's weight relative to other target VMs.
    HealthCheck NetworkloadbalancerForwardingruleTargetHealthCheck
    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 float64
    [int] Port of the balanced target service. (range: 1 to 65535).
    Weight float64
    [int] Weight parameter is used to adjust the target VM's weight relative to other target VMs.
    HealthCheck NetworkloadbalancerForwardingruleTargetHealthCheck
    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 Double
    [int] Port of the balanced target service. (range: 1 to 65535).
    weight Double
    [int] Weight parameter is used to adjust the target VM's weight relative to other target VMs.
    healthCheck NetworkloadbalancerForwardingruleTargetHealthCheck
    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 NetworkloadbalancerForwardingruleTargetHealthCheck
    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 float
    [int] Port of the balanced target service. (range: 1 to 65535).
    weight float
    [int] Weight parameter is used to adjust the target VM's weight relative to other target VMs.
    health_check NetworkloadbalancerForwardingruleTargetHealthCheck
    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.

    NetworkloadbalancerForwardingruleTargetHealthCheck, NetworkloadbalancerForwardingruleTargetHealthCheckArgs

    Check bool
    [boolean] Check specifies whether the target VM's health is checked.
    CheckInterval double
    [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 float64
    [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 Double
    [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 float
    [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.

    NetworkloadbalancerForwardingruleTimeouts, NetworkloadbalancerForwardingruleTimeoutsArgs

    Create string
    Default string
    Delete string
    Update string
    Create string
    Default string
    Delete string
    Update string
    create String
    default_ String
    delete String
    update String
    create string
    default string
    delete string
    update string
    create String
    default String
    delete String
    update String

    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:index/networkloadbalancerForwardingrule:NetworkloadbalancerForwardingrule 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/terraform-provider-ionoscloud
    License
    Notes
    This Pulumi package is based on the ionoscloud Terraform Provider.
    ionoscloud logo
    ionoscloud 6.7.6 published on Monday, Apr 14, 2025 by ionos-cloud
    ionos-cloud/terraform-provider-ionoscloud