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

ionoscloud.ApplicationLoadbalancerForwardingrule

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 an Application Load Balancer Forwarding Rule on IonosCloud.

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
import * as fs from "fs";
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": true,
});
const example2 = new ionoscloud.Lan("example2", {
    datacenterId: exampleDatacenter.datacenterId,
    "public": true,
});
const exampleApplicationLoadbalancer = new ionoscloud.ApplicationLoadbalancer("exampleApplicationLoadbalancer", {
    datacenterId: exampleDatacenter.datacenterId,
    listenerLan: example1.lanId,
    ips: ["10.12.118.224"],
    targetLan: example2.lanId,
    lbPrivateIps: ["10.13.72.225/24"],
});
//optionally you can add a certificate to the application load balancer
const cert = new ionoscloud.Certificate("cert", {
    certificate: fs.readFileSync("path_to_cert", "utf8"),
    certificateChain: fs.readFileSync("path_to_cert_chain", "utf8"),
    privateKey: fs.readFileSync("path_to_private_key", "utf8"),
});
const exampleApplicationLoadbalancerForwardingrule = new ionoscloud.ApplicationLoadbalancerForwardingrule("exampleApplicationLoadbalancerForwardingrule", {
    datacenterId: exampleDatacenter.datacenterId,
    applicationLoadbalancerId: exampleApplicationLoadbalancer.applicationLoadbalancerId,
    protocol: "HTTP",
    listenerIp: "10.12.118.224",
    listenerPort: 8080,
    clientTimeout: 1000,
    httpRules: [
        {
            name: "http_rule",
            type: "REDIRECT",
            dropQuery: true,
            location: "www.ionos.com",
            statusCode: 301,
            conditions: [{
                type: "HEADER",
                condition: "EQUALS",
                negate: true,
                key: "key",
                value: "10.12.120.224/24",
            }],
        },
        {
            name: "http_rule_2",
            type: "STATIC",
            dropQuery: false,
            statusCode: 303,
            responseMessage: "Response",
            contentType: "text/plain",
            conditions: [{
                type: "QUERY",
                condition: "MATCHES",
                negate: false,
                key: "key",
                value: "10.12.120.224/24",
            }],
        },
    ],
    serverCertificates: [cert.certificateId],
});

    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=True)
example2 = ionoscloud.Lan("example2",
    datacenter_id=example_datacenter.datacenter_id,
    public=True)
example_application_loadbalancer = ionoscloud.ApplicationLoadbalancer("exampleApplicationLoadbalancer",
    datacenter_id=example_datacenter.datacenter_id,
    listener_lan=example1.lan_id,
    ips=["10.12.118.224"],
    target_lan=example2.lan_id,
    lb_private_ips=["10.13.72.225/24"])
#optionally you can add a certificate to the application load balancer
cert = ionoscloud.Certificate("cert",
    certificate=(lambda path: open(path).read())("path_to_cert"),
    certificate_chain=(lambda path: open(path).read())("path_to_cert_chain"),
    private_key=(lambda path: open(path).read())("path_to_private_key"))
example_application_loadbalancer_forwardingrule = ionoscloud.ApplicationLoadbalancerForwardingrule("exampleApplicationLoadbalancerForwardingrule",
    datacenter_id=example_datacenter.datacenter_id,
    application_loadbalancer_id=example_application_loadbalancer.application_loadbalancer_id,
    protocol="HTTP",
    listener_ip="10.12.118.224",
    listener_port=8080,
    client_timeout=1000,
    http_rules=[
        {
            "name": "http_rule",
            "type": "REDIRECT",
            "drop_query": True,
            "location": "www.ionos.com",
            "status_code": 301,
            "conditions": [{
                "type": "HEADER",
                "condition": "EQUALS",
                "negate": True,
                "key": "key",
                "value": "10.12.120.224/24",
            }],
        },
        {
            "name": "http_rule_2",
            "type": "STATIC",
            "drop_query": False,
            "status_code": 303,
            "response_message": "Response",
            "content_type": "text/plain",
            "conditions": [{
                "type": "QUERY",
                "condition": "MATCHES",
                "negate": False,
                "key": "key",
                "value": "10.12.120.224/24",
            }],
        },
    ],
    server_certificates=[cert.certificate_id])

    package main

import (
	"os"

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

func readFileOrPanic(path string) pulumi.StringPtrInput {
	data, err := os.ReadFile(path)
	if err != nil {
		panic(err.Error())
	}
	return pulumi.String(string(data))
}

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(true),
		})
		if err != nil {
			return err
		}
		example2, err := ionoscloud.NewLan(ctx, "example2", &ionoscloud.LanArgs{
			DatacenterId: exampleDatacenter.DatacenterId,
			Public:       pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		exampleApplicationLoadbalancer, err := ionoscloud.NewApplicationLoadbalancer(ctx, "exampleApplicationLoadbalancer", &ionoscloud.ApplicationLoadbalancerArgs{
			DatacenterId: exampleDatacenter.DatacenterId,
			ListenerLan:  example1.LanId,
			Ips: pulumi.StringArray{
				pulumi.String("10.12.118.224"),
			},
			TargetLan: example2.LanId,
			LbPrivateIps: pulumi.StringArray{
				pulumi.String("10.13.72.225/24"),
			},
		})
		if err != nil {
			return err
		}
		// optionally you can add a certificate to the application load balancer
		cert, err := ionoscloud.NewCertificate(ctx, "cert", &ionoscloud.CertificateArgs{
			Certificate:      pulumi.String(readFileOrPanic("path_to_cert")),
			CertificateChain: pulumi.String(readFileOrPanic("path_to_cert_chain")),
			PrivateKey:       pulumi.String(readFileOrPanic("path_to_private_key")),
		})
		if err != nil {
			return err
		}
		_, err = ionoscloud.NewApplicationLoadbalancerForwardingrule(ctx, "exampleApplicationLoadbalancerForwardingrule", &ionoscloud.ApplicationLoadbalancerForwardingruleArgs{
			DatacenterId:              exampleDatacenter.DatacenterId,
			ApplicationLoadbalancerId: exampleApplicationLoadbalancer.ApplicationLoadbalancerId,
			Protocol:                  pulumi.String("HTTP"),
			ListenerIp:                pulumi.String("10.12.118.224"),
			ListenerPort:              pulumi.Float64(8080),
			ClientTimeout:             pulumi.Float64(1000),
			HttpRules: ionoscloud.ApplicationLoadbalancerForwardingruleHttpRuleArray{
				&ionoscloud.ApplicationLoadbalancerForwardingruleHttpRuleArgs{
					Name:       pulumi.String("http_rule"),
					Type:       pulumi.String("REDIRECT"),
					DropQuery:  pulumi.Bool(true),
					Location:   pulumi.String("www.ionos.com"),
					StatusCode: pulumi.Float64(301),
					Conditions: ionoscloud.ApplicationLoadbalancerForwardingruleHttpRuleConditionArray{
						&ionoscloud.ApplicationLoadbalancerForwardingruleHttpRuleConditionArgs{
							Type:      pulumi.String("HEADER"),
							Condition: pulumi.String("EQUALS"),
							Negate:    pulumi.Bool(true),
							Key:       pulumi.String("key"),
							Value:     pulumi.String("10.12.120.224/24"),
						},
					},
				},
				&ionoscloud.ApplicationLoadbalancerForwardingruleHttpRuleArgs{
					Name:            pulumi.String("http_rule_2"),
					Type:            pulumi.String("STATIC"),
					DropQuery:       pulumi.Bool(false),
					StatusCode:      pulumi.Float64(303),
					ResponseMessage: pulumi.String("Response"),
					ContentType:     pulumi.String("text/plain"),
					Conditions: ionoscloud.ApplicationLoadbalancerForwardingruleHttpRuleConditionArray{
						&ionoscloud.ApplicationLoadbalancerForwardingruleHttpRuleConditionArgs{
							Type:      pulumi.String("QUERY"),
							Condition: pulumi.String("MATCHES"),
							Negate:    pulumi.Bool(false),
							Key:       pulumi.String("key"),
							Value:     pulumi.String("10.12.120.224/24"),
						},
					},
				},
			},
			ServerCertificates: pulumi.StringArray{
				cert.CertificateId,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.IO;
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 = true,
    });

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

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

    //optionally you can add a certificate to the application load balancer
    var cert = new Ionoscloud.Certificate("cert", new()
    {
        Certificate = File.ReadAllText("path_to_cert"),
        CertificateChain = File.ReadAllText("path_to_cert_chain"),
        PrivateKey = File.ReadAllText("path_to_private_key"),
    });

    var exampleApplicationLoadbalancerForwardingrule = new Ionoscloud.ApplicationLoadbalancerForwardingrule("exampleApplicationLoadbalancerForwardingrule", new()
    {
        DatacenterId = exampleDatacenter.DatacenterId,
        ApplicationLoadbalancerId = exampleApplicationLoadbalancer.ApplicationLoadbalancerId,
        Protocol = "HTTP",
        ListenerIp = "10.12.118.224",
        ListenerPort = 8080,
        ClientTimeout = 1000,
        HttpRules = new[]
        {
            new Ionoscloud.Inputs.ApplicationLoadbalancerForwardingruleHttpRuleArgs
            {
                Name = "http_rule",
                Type = "REDIRECT",
                DropQuery = true,
                Location = "www.ionos.com",
                StatusCode = 301,
                Conditions = new[]
                {
                    new Ionoscloud.Inputs.ApplicationLoadbalancerForwardingruleHttpRuleConditionArgs
                    {
                        Type = "HEADER",
                        Condition = "EQUALS",
                        Negate = true,
                        Key = "key",
                        Value = "10.12.120.224/24",
                    },
                },
            },
            new Ionoscloud.Inputs.ApplicationLoadbalancerForwardingruleHttpRuleArgs
            {
                Name = "http_rule_2",
                Type = "STATIC",
                DropQuery = false,
                StatusCode = 303,
                ResponseMessage = "Response",
                ContentType = "text/plain",
                Conditions = new[]
                {
                    new Ionoscloud.Inputs.ApplicationLoadbalancerForwardingruleHttpRuleConditionArgs
                    {
                        Type = "QUERY",
                        Condition = "MATCHES",
                        Negate = false,
                        Key = "key",
                        Value = "10.12.120.224/24",
                    },
                },
            },
        },
        ServerCertificates = new[]
        {
            cert.CertificateId,
        },
    });

});

    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.ApplicationLoadbalancer;
import com.pulumi.ionoscloud.ApplicationLoadbalancerArgs;
import com.pulumi.ionoscloud.Certificate;
import com.pulumi.ionoscloud.CertificateArgs;
import com.pulumi.ionoscloud.ApplicationLoadbalancerForwardingrule;
import com.pulumi.ionoscloud.ApplicationLoadbalancerForwardingruleArgs;
import com.pulumi.ionoscloud.inputs.ApplicationLoadbalancerForwardingruleHttpRuleArgs;
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_(true)
            .build());

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

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

        //optionally you can add a certificate to the application load balancer
        var cert = new Certificate("cert", CertificateArgs.builder()
            .certificate(Files.readString(Paths.get("path_to_cert")))
            .certificateChain(Files.readString(Paths.get("path_to_cert_chain")))
            .privateKey(Files.readString(Paths.get("path_to_private_key")))
            .build());

        var exampleApplicationLoadbalancerForwardingrule = new ApplicationLoadbalancerForwardingrule("exampleApplicationLoadbalancerForwardingrule", ApplicationLoadbalancerForwardingruleArgs.builder()
            .datacenterId(exampleDatacenter.datacenterId())
            .applicationLoadbalancerId(exampleApplicationLoadbalancer.applicationLoadbalancerId())
            .protocol("HTTP")
            .listenerIp("10.12.118.224")
            .listenerPort(8080)
            .clientTimeout(1000)
            .httpRules(            
                ApplicationLoadbalancerForwardingruleHttpRuleArgs.builder()
                    .name("http_rule")
                    .type("REDIRECT")
                    .dropQuery(true)
                    .location("www.ionos.com")
                    .statusCode(301)
                    .conditions(ApplicationLoadbalancerForwardingruleHttpRuleConditionArgs.builder()
                        .type("HEADER")
                        .condition("EQUALS")
                        .negate(true)
                        .key("key")
                        .value("10.12.120.224/24")
                        .build())
                    .build(),
                ApplicationLoadbalancerForwardingruleHttpRuleArgs.builder()
                    .name("http_rule_2")
                    .type("STATIC")
                    .dropQuery(false)
                    .statusCode(303)
                    .responseMessage("Response")
                    .contentType("text/plain")
                    .conditions(ApplicationLoadbalancerForwardingruleHttpRuleConditionArgs.builder()
                        .type("QUERY")
                        .condition("MATCHES")
                        .negate(false)
                        .key("key")
                        .value("10.12.120.224/24")
                        .build())
                    .build())
            .serverCertificates(cert.certificateId())
            .build());

    }
}

    resources:
  exampleDatacenter:
    type: ionoscloud:Datacenter
    properties:
      location: us/las
      description: datacenter description
      secAuthProtection: false
  example1:
    type: ionoscloud:Lan
    properties:
      datacenterId: ${exampleDatacenter.datacenterId}
      public: true
  example2:
    type: ionoscloud:Lan
    properties:
      datacenterId: ${exampleDatacenter.datacenterId}
      public: true
  exampleApplicationLoadbalancer:
    type: ionoscloud:ApplicationLoadbalancer
    properties:
      datacenterId: ${exampleDatacenter.datacenterId}
      listenerLan: ${example1.lanId}
      ips:
        - 10.12.118.224
      targetLan: ${example2.lanId}
      lbPrivateIps:
        - 10.13.72.225/24
  exampleApplicationLoadbalancerForwardingrule:
    type: ionoscloud:ApplicationLoadbalancerForwardingrule
    properties:
      datacenterId: ${exampleDatacenter.datacenterId}
      applicationLoadbalancerId: ${exampleApplicationLoadbalancer.applicationLoadbalancerId}
      protocol: HTTP
      listenerIp: 10.12.118.224
      listenerPort: 8080
      clientTimeout: 1000
      httpRules:
        - name: http_rule
          type: REDIRECT
          dropQuery: true
          location: www.ionos.com
          statusCode: 301
          conditions:
            - type: HEADER
              condition: EQUALS
              negate: true
              key: key
              value: 10.12.120.224/24
        - name: http_rule_2
          type: STATIC
          dropQuery: false
          statusCode: 303
          responseMessage: Response
          contentType: text/plain
          conditions:
            - type: QUERY
              condition: MATCHES
              negate: false
              key: key
              value: 10.12.120.224/24
      serverCertificates:
        - ${cert.certificateId}
  #optionally you can add a certificate to the application load balancer
  cert:
    type: ionoscloud:Certificate
    properties:
      certificate:
        fn::readFile: path_to_cert
      certificateChain:
        fn::readFile: path_to_cert_chain
      privateKey:
        fn::readFile: path_to_private_key

    Create ApplicationLoadbalancerForwardingrule Resource

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

    Constructor syntax

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

@overload
def ApplicationLoadbalancerForwardingrule(resource_name: str,
                                          opts: Optional[ResourceOptions] = None,
                                          application_loadbalancer_id: Optional[str] = None,
                                          datacenter_id: Optional[str] = None,
                                          listener_ip: Optional[str] = None,
                                          listener_port: Optional[float] = None,
                                          protocol: Optional[str] = None,
                                          application_loadbalancer_forwardingrule_id: Optional[str] = None,
                                          client_timeout: Optional[float] = None,
                                          http_rules: Optional[Sequence[ApplicationLoadbalancerForwardingruleHttpRuleArgs]] = None,
                                          name: Optional[str] = None,
                                          server_certificates: Optional[Sequence[str]] = None,
                                          timeouts: Optional[ApplicationLoadbalancerForwardingruleTimeoutsArgs] = None)
    func NewApplicationLoadbalancerForwardingrule(ctx *Context, name string, args ApplicationLoadbalancerForwardingruleArgs, opts ...ResourceOption) (*ApplicationLoadbalancerForwardingrule, error)
    public ApplicationLoadbalancerForwardingrule(string name, ApplicationLoadbalancerForwardingruleArgs args, CustomResourceOptions? opts = null)
    public ApplicationLoadbalancerForwardingrule(String name, ApplicationLoadbalancerForwardingruleArgs args)
public ApplicationLoadbalancerForwardingrule(String name, ApplicationLoadbalancerForwardingruleArgs args, CustomResourceOptions options)

    type: ionoscloud:ApplicationLoadbalancerForwardingrule
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 ApplicationLoadbalancerForwardingruleArgs
    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 ApplicationLoadbalancerForwardingruleArgs
    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 ApplicationLoadbalancerForwardingruleArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args ApplicationLoadbalancerForwardingruleArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args ApplicationLoadbalancerForwardingruleArgs
    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 applicationLoadbalancerForwardingruleResource = new Ionoscloud.ApplicationLoadbalancerForwardingrule("applicationLoadbalancerForwardingruleResource", new()
{
    ApplicationLoadbalancerId = "string",
    DatacenterId = "string",
    ListenerIp = "string",
    ListenerPort = 0,
    Protocol = "string",
    ApplicationLoadbalancerForwardingruleId = "string",
    ClientTimeout = 0,
    HttpRules = new[]
    {
        new Ionoscloud.Inputs.ApplicationLoadbalancerForwardingruleHttpRuleArgs
        {
            Name = "string",
            Type = "string",
            Conditions = new[]
            {
                new Ionoscloud.Inputs.ApplicationLoadbalancerForwardingruleHttpRuleConditionArgs
                {
                    Type = "string",
                    Condition = "string",
                    Key = "string",
                    Negate = false,
                    Value = "string",
                },
            },
            ContentType = "string",
            DropQuery = false,
            Location = "string",
            ResponseMessage = "string",
            StatusCode = 0,
            TargetGroup = "string",
        },
    },
    Name = "string",
    ServerCertificates = new[]
    {
        "string",
    },
    Timeouts = new Ionoscloud.Inputs.ApplicationLoadbalancerForwardingruleTimeoutsArgs
    {
        Create = "string",
        Default = "string",
        Delete = "string",
        Update = "string",
    },
});

    example, err := ionoscloud.NewApplicationLoadbalancerForwardingrule(ctx, "applicationLoadbalancerForwardingruleResource", &ionoscloud.ApplicationLoadbalancerForwardingruleArgs{
	ApplicationLoadbalancerId:               pulumi.String("string"),
	DatacenterId:                            pulumi.String("string"),
	ListenerIp:                              pulumi.String("string"),
	ListenerPort:                            pulumi.Float64(0),
	Protocol:                                pulumi.String("string"),
	ApplicationLoadbalancerForwardingruleId: pulumi.String("string"),
	ClientTimeout:                           pulumi.Float64(0),
	HttpRules: ionoscloud.ApplicationLoadbalancerForwardingruleHttpRuleArray{
		&ionoscloud.ApplicationLoadbalancerForwardingruleHttpRuleArgs{
			Name: pulumi.String("string"),
			Type: pulumi.String("string"),
			Conditions: ionoscloud.ApplicationLoadbalancerForwardingruleHttpRuleConditionArray{
				&ionoscloud.ApplicationLoadbalancerForwardingruleHttpRuleConditionArgs{
					Type:      pulumi.String("string"),
					Condition: pulumi.String("string"),
					Key:       pulumi.String("string"),
					Negate:    pulumi.Bool(false),
					Value:     pulumi.String("string"),
				},
			},
			ContentType:     pulumi.String("string"),
			DropQuery:       pulumi.Bool(false),
			Location:        pulumi.String("string"),
			ResponseMessage: pulumi.String("string"),
			StatusCode:      pulumi.Float64(0),
			TargetGroup:     pulumi.String("string"),
		},
	},
	Name: pulumi.String("string"),
	ServerCertificates: pulumi.StringArray{
		pulumi.String("string"),
	},
	Timeouts: &ionoscloud.ApplicationLoadbalancerForwardingruleTimeoutsArgs{
		Create:  pulumi.String("string"),
		Default: pulumi.String("string"),
		Delete:  pulumi.String("string"),
		Update:  pulumi.String("string"),
	},
})

    var applicationLoadbalancerForwardingruleResource = new ApplicationLoadbalancerForwardingrule("applicationLoadbalancerForwardingruleResource", ApplicationLoadbalancerForwardingruleArgs.builder()
    .applicationLoadbalancerId("string")
    .datacenterId("string")
    .listenerIp("string")
    .listenerPort(0)
    .protocol("string")
    .applicationLoadbalancerForwardingruleId("string")
    .clientTimeout(0)
    .httpRules(ApplicationLoadbalancerForwardingruleHttpRuleArgs.builder()
        .name("string")
        .type("string")
        .conditions(ApplicationLoadbalancerForwardingruleHttpRuleConditionArgs.builder()
            .type("string")
            .condition("string")
            .key("string")
            .negate(false)
            .value("string")
            .build())
        .contentType("string")
        .dropQuery(false)
        .location("string")
        .responseMessage("string")
        .statusCode(0)
        .targetGroup("string")
        .build())
    .name("string")
    .serverCertificates("string")
    .timeouts(ApplicationLoadbalancerForwardingruleTimeoutsArgs.builder()
        .create("string")
        .default_("string")
        .delete("string")
        .update("string")
        .build())
    .build());

    application_loadbalancer_forwardingrule_resource = ionoscloud.ApplicationLoadbalancerForwardingrule("applicationLoadbalancerForwardingruleResource",
    application_loadbalancer_id="string",
    datacenter_id="string",
    listener_ip="string",
    listener_port=0,
    protocol="string",
    application_loadbalancer_forwardingrule_id="string",
    client_timeout=0,
    http_rules=[{
        "name": "string",
        "type": "string",
        "conditions": [{
            "type": "string",
            "condition": "string",
            "key": "string",
            "negate": False,
            "value": "string",
        }],
        "content_type": "string",
        "drop_query": False,
        "location": "string",
        "response_message": "string",
        "status_code": 0,
        "target_group": "string",
    }],
    name="string",
    server_certificates=["string"],
    timeouts={
        "create": "string",
        "default": "string",
        "delete": "string",
        "update": "string",
    })

    const applicationLoadbalancerForwardingruleResource = new ionoscloud.ApplicationLoadbalancerForwardingrule("applicationLoadbalancerForwardingruleResource", {
    applicationLoadbalancerId: "string",
    datacenterId: "string",
    listenerIp: "string",
    listenerPort: 0,
    protocol: "string",
    applicationLoadbalancerForwardingruleId: "string",
    clientTimeout: 0,
    httpRules: [{
        name: "string",
        type: "string",
        conditions: [{
            type: "string",
            condition: "string",
            key: "string",
            negate: false,
            value: "string",
        }],
        contentType: "string",
        dropQuery: false,
        location: "string",
        responseMessage: "string",
        statusCode: 0,
        targetGroup: "string",
    }],
    name: "string",
    serverCertificates: ["string"],
    timeouts: {
        create: "string",
        "default": "string",
        "delete": "string",
        update: "string",
    },
});

    type: ionoscloud:ApplicationLoadbalancerForwardingrule
properties:
    applicationLoadbalancerForwardingruleId: string
    applicationLoadbalancerId: string
    clientTimeout: 0
    datacenterId: string
    httpRules:
        - conditions:
            - condition: string
              key: string
              negate: false
              type: string
              value: string
          contentType: string
          dropQuery: false
          location: string
          name: string
          responseMessage: string
          statusCode: 0
          targetGroup: string
          type: string
    listenerIp: string
    listenerPort: 0
    name: string
    protocol: string
    serverCertificates:
        - string
    timeouts:
        create: string
        default: string
        delete: string
        update: string

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

    ApplicationLoadbalancerId string
    [string] The ID of Application Load Balancer.
    DatacenterId string
    [string] The ID of a Virtual Data Center.
    ListenerIp string
    [string] Listening (inbound) IP.
    ListenerPort double
    [int] Listening (inbound) port number; valid range is 1 to 65535.
    Protocol string
    [string] Balancing protocol.
    ApplicationLoadbalancerForwardingruleId string
    ClientTimeout double
    [int] The maximum time in milliseconds to wait for the client to acknowledge or send data; default is 50,000 (50 seconds).
    HttpRules List<ApplicationLoadbalancerForwardingruleHttpRule>
    [list] Array of items in that collection
    Name string
    [string] The name of the Application Load Balancer forwarding rule.
    ServerCertificates List<string>
    [list] Array of certificate ids. You can create certificates with the certificate resource.
    Timeouts ApplicationLoadbalancerForwardingruleTimeouts
    ApplicationLoadbalancerId string
    [string] The ID of Application Load Balancer.
    DatacenterId string
    [string] The ID of a Virtual Data Center.
    ListenerIp string
    [string] Listening (inbound) IP.
    ListenerPort float64
    [int] Listening (inbound) port number; valid range is 1 to 65535.
    Protocol string
    [string] Balancing protocol.
    ApplicationLoadbalancerForwardingruleId string
    ClientTimeout float64
    [int] The maximum time in milliseconds to wait for the client to acknowledge or send data; default is 50,000 (50 seconds).
    HttpRules []ApplicationLoadbalancerForwardingruleHttpRuleArgs
    [list] Array of items in that collection
    Name string
    [string] The name of the Application Load Balancer forwarding rule.
    ServerCertificates []string
    [list] Array of certificate ids. You can create certificates with the certificate resource.
    Timeouts ApplicationLoadbalancerForwardingruleTimeoutsArgs
    applicationLoadbalancerId String
    [string] The ID of Application Load Balancer.
    datacenterId String
    [string] The ID of a Virtual Data Center.
    listenerIp String
    [string] Listening (inbound) IP.
    listenerPort Double
    [int] Listening (inbound) port number; valid range is 1 to 65535.
    protocol String
    [string] Balancing protocol.
    applicationLoadbalancerForwardingruleId String
    clientTimeout Double
    [int] The maximum time in milliseconds to wait for the client to acknowledge or send data; default is 50,000 (50 seconds).
    httpRules List<ApplicationLoadbalancerForwardingruleHttpRule>
    [list] Array of items in that collection
    name String
    [string] The name of the Application Load Balancer forwarding rule.
    serverCertificates List<String>
    [list] Array of certificate ids. You can create certificates with the certificate resource.
    timeouts ApplicationLoadbalancerForwardingruleTimeouts
    applicationLoadbalancerId string
    [string] The ID of Application Load Balancer.
    datacenterId string
    [string] The ID of a Virtual Data Center.
    listenerIp string
    [string] Listening (inbound) IP.
    listenerPort number
    [int] Listening (inbound) port number; valid range is 1 to 65535.
    protocol string
    [string] Balancing protocol.
    applicationLoadbalancerForwardingruleId string
    clientTimeout number
    [int] The maximum time in milliseconds to wait for the client to acknowledge or send data; default is 50,000 (50 seconds).
    httpRules ApplicationLoadbalancerForwardingruleHttpRule[]
    [list] Array of items in that collection
    name string
    [string] The name of the Application Load Balancer forwarding rule.
    serverCertificates string[]
    [list] Array of certificate ids. You can create certificates with the certificate resource.
    timeouts ApplicationLoadbalancerForwardingruleTimeouts
    application_loadbalancer_id str
    [string] The ID of Application Load Balancer.
    datacenter_id str
    [string] The ID of a Virtual Data Center.
    listener_ip str
    [string] Listening (inbound) IP.
    listener_port float
    [int] Listening (inbound) port number; valid range is 1 to 65535.
    protocol str
    [string] Balancing protocol.
    application_loadbalancer_forwardingrule_id str
    client_timeout float
    [int] The maximum time in milliseconds to wait for the client to acknowledge or send data; default is 50,000 (50 seconds).
    http_rules Sequence[ApplicationLoadbalancerForwardingruleHttpRuleArgs]
    [list] Array of items in that collection
    name str
    [string] The name of the Application Load Balancer forwarding rule.
    server_certificates Sequence[str]
    [list] Array of certificate ids. You can create certificates with the certificate resource.
    timeouts ApplicationLoadbalancerForwardingruleTimeoutsArgs
    applicationLoadbalancerId String
    [string] The ID of Application Load Balancer.
    datacenterId String
    [string] The ID of a Virtual Data Center.
    listenerIp String
    [string] Listening (inbound) IP.
    listenerPort Number
    [int] Listening (inbound) port number; valid range is 1 to 65535.
    protocol String
    [string] Balancing protocol.
    applicationLoadbalancerForwardingruleId String
    clientTimeout Number
    [int] The maximum time in milliseconds to wait for the client to acknowledge or send data; default is 50,000 (50 seconds).
    httpRules List<Property Map>
    [list] Array of items in that collection
    name String
    [string] The name of the Application Load Balancer forwarding rule.
    serverCertificates List<String>
    [list] Array of certificate ids. You can create certificates with the certificate resource.
    timeouts Property Map

    Outputs

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

    Get an existing ApplicationLoadbalancerForwardingrule 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?: ApplicationLoadbalancerForwardingruleState, opts?: CustomResourceOptions): ApplicationLoadbalancerForwardingrule
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        application_loadbalancer_forwardingrule_id: Optional[str] = None,
        application_loadbalancer_id: Optional[str] = None,
        client_timeout: Optional[float] = None,
        datacenter_id: Optional[str] = None,
        http_rules: Optional[Sequence[ApplicationLoadbalancerForwardingruleHttpRuleArgs]] = None,
        listener_ip: Optional[str] = None,
        listener_port: Optional[float] = None,
        name: Optional[str] = None,
        protocol: Optional[str] = None,
        server_certificates: Optional[Sequence[str]] = None,
        timeouts: Optional[ApplicationLoadbalancerForwardingruleTimeoutsArgs] = None) -> ApplicationLoadbalancerForwardingrule
    func GetApplicationLoadbalancerForwardingrule(ctx *Context, name string, id IDInput, state *ApplicationLoadbalancerForwardingruleState, opts ...ResourceOption) (*ApplicationLoadbalancerForwardingrule, error)
    public static ApplicationLoadbalancerForwardingrule Get(string name, Input<string> id, ApplicationLoadbalancerForwardingruleState? state, CustomResourceOptions? opts = null)
    public static ApplicationLoadbalancerForwardingrule get(String name, Output<String> id, ApplicationLoadbalancerForwardingruleState state, CustomResourceOptions options)
    resources:  _:    type: ionoscloud:ApplicationLoadbalancerForwardingrule    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:
    ApplicationLoadbalancerForwardingruleId string
    ApplicationLoadbalancerId string
    [string] The ID of Application Load Balancer.
    ClientTimeout double
    [int] The maximum time in milliseconds to wait for the client to acknowledge or send data; default is 50,000 (50 seconds).
    DatacenterId string
    [string] The ID of a Virtual Data Center.
    HttpRules List<ApplicationLoadbalancerForwardingruleHttpRule>
    [list] Array of items in that collection
    ListenerIp string
    [string] Listening (inbound) IP.
    ListenerPort double
    [int] Listening (inbound) port number; valid range is 1 to 65535.
    Name string
    [string] The name of the Application Load Balancer forwarding rule.
    Protocol string
    [string] Balancing protocol.
    ServerCertificates List<string>
    [list] Array of certificate ids. You can create certificates with the certificate resource.
    Timeouts ApplicationLoadbalancerForwardingruleTimeouts
    ApplicationLoadbalancerForwardingruleId string
    ApplicationLoadbalancerId string
    [string] The ID of Application Load Balancer.
    ClientTimeout float64
    [int] The maximum time in milliseconds to wait for the client to acknowledge or send data; default is 50,000 (50 seconds).
    DatacenterId string
    [string] The ID of a Virtual Data Center.
    HttpRules []ApplicationLoadbalancerForwardingruleHttpRuleArgs
    [list] Array of items in that collection
    ListenerIp string
    [string] Listening (inbound) IP.
    ListenerPort float64
    [int] Listening (inbound) port number; valid range is 1 to 65535.
    Name string
    [string] The name of the Application Load Balancer forwarding rule.
    Protocol string
    [string] Balancing protocol.
    ServerCertificates []string
    [list] Array of certificate ids. You can create certificates with the certificate resource.
    Timeouts ApplicationLoadbalancerForwardingruleTimeoutsArgs
    applicationLoadbalancerForwardingruleId String
    applicationLoadbalancerId String
    [string] The ID of Application Load Balancer.
    clientTimeout Double
    [int] The maximum time in milliseconds to wait for the client to acknowledge or send data; default is 50,000 (50 seconds).
    datacenterId String
    [string] The ID of a Virtual Data Center.
    httpRules List<ApplicationLoadbalancerForwardingruleHttpRule>
    [list] Array of items in that collection
    listenerIp String
    [string] Listening (inbound) IP.
    listenerPort Double
    [int] Listening (inbound) port number; valid range is 1 to 65535.
    name String
    [string] The name of the Application Load Balancer forwarding rule.
    protocol String
    [string] Balancing protocol.
    serverCertificates List<String>
    [list] Array of certificate ids. You can create certificates with the certificate resource.
    timeouts ApplicationLoadbalancerForwardingruleTimeouts
    applicationLoadbalancerForwardingruleId string
    applicationLoadbalancerId string
    [string] The ID of Application Load Balancer.
    clientTimeout number
    [int] The maximum time in milliseconds to wait for the client to acknowledge or send data; default is 50,000 (50 seconds).
    datacenterId string
    [string] The ID of a Virtual Data Center.
    httpRules ApplicationLoadbalancerForwardingruleHttpRule[]
    [list] Array of items in that collection
    listenerIp string
    [string] Listening (inbound) IP.
    listenerPort number
    [int] Listening (inbound) port number; valid range is 1 to 65535.
    name string
    [string] The name of the Application Load Balancer forwarding rule.
    protocol string
    [string] Balancing protocol.
    serverCertificates string[]
    [list] Array of certificate ids. You can create certificates with the certificate resource.
    timeouts ApplicationLoadbalancerForwardingruleTimeouts
    application_loadbalancer_forwardingrule_id str
    application_loadbalancer_id str
    [string] The ID of Application Load Balancer.
    client_timeout float
    [int] The maximum time in milliseconds to wait for the client to acknowledge or send data; default is 50,000 (50 seconds).
    datacenter_id str
    [string] The ID of a Virtual Data Center.
    http_rules Sequence[ApplicationLoadbalancerForwardingruleHttpRuleArgs]
    [list] Array of items in that collection
    listener_ip str
    [string] Listening (inbound) IP.
    listener_port float
    [int] Listening (inbound) port number; valid range is 1 to 65535.
    name str
    [string] The name of the Application Load Balancer forwarding rule.
    protocol str
    [string] Balancing protocol.
    server_certificates Sequence[str]
    [list] Array of certificate ids. You can create certificates with the certificate resource.
    timeouts ApplicationLoadbalancerForwardingruleTimeoutsArgs
    applicationLoadbalancerForwardingruleId String
    applicationLoadbalancerId String
    [string] The ID of Application Load Balancer.
    clientTimeout Number
    [int] The maximum time in milliseconds to wait for the client to acknowledge or send data; default is 50,000 (50 seconds).
    datacenterId String
    [string] The ID of a Virtual Data Center.
    httpRules List<Property Map>
    [list] Array of items in that collection
    listenerIp String
    [string] Listening (inbound) IP.
    listenerPort Number
    [int] Listening (inbound) port number; valid range is 1 to 65535.
    name String
    [string] The name of the Application Load Balancer forwarding rule.
    protocol String
    [string] Balancing protocol.
    serverCertificates List<String>
    [list] Array of certificate ids. You can create certificates with the certificate resource.
    timeouts Property Map

    Supporting Types

    ApplicationLoadbalancerForwardingruleHttpRule, ApplicationLoadbalancerForwardingruleHttpRuleArgs

    Name string
    [string] The unique name of the Application Load Balancer HTTP rule.
    Type string
    [string] Type of the Http Rule.
    Conditions List<ApplicationLoadbalancerForwardingruleHttpRuleCondition>
    [list] - An array of items in the collection.The action is only performed if each and every condition is met; if no conditions are set, the rule will always be performed.
    ContentType string
    [string] Valid only for STATIC actions.
    DropQuery bool
    [bool] Default is false; valid only for REDIRECT actions.
    Location string
    [string] The location for redirecting; mandatory and valid only for REDIRECT actions.
    ResponseMessage string
    [string] The response message of the request; mandatory for STATIC action.
    StatusCode double
    [int] Valid only for REDIRECT and STATIC actions. For REDIRECT actions, default is 301 and possible values are 301, 302, 303, 307, and 308. For STATIC actions, default is 503 and valid range is 200 to 599.
    TargetGroup string
    [string] The UUID of the target group; mandatory for FORWARD action.
    Name string
    [string] The unique name of the Application Load Balancer HTTP rule.
    Type string
    [string] Type of the Http Rule.
    Conditions []ApplicationLoadbalancerForwardingruleHttpRuleCondition
    [list] - An array of items in the collection.The action is only performed if each and every condition is met; if no conditions are set, the rule will always be performed.
    ContentType string
    [string] Valid only for STATIC actions.
    DropQuery bool
    [bool] Default is false; valid only for REDIRECT actions.
    Location string
    [string] The location for redirecting; mandatory and valid only for REDIRECT actions.
    ResponseMessage string
    [string] The response message of the request; mandatory for STATIC action.
    StatusCode float64
    [int] Valid only for REDIRECT and STATIC actions. For REDIRECT actions, default is 301 and possible values are 301, 302, 303, 307, and 308. For STATIC actions, default is 503 and valid range is 200 to 599.
    TargetGroup string
    [string] The UUID of the target group; mandatory for FORWARD action.
    name String
    [string] The unique name of the Application Load Balancer HTTP rule.
    type String
    [string] Type of the Http Rule.
    conditions List<ApplicationLoadbalancerForwardingruleHttpRuleCondition>
    [list] - An array of items in the collection.The action is only performed if each and every condition is met; if no conditions are set, the rule will always be performed.
    contentType String
    [string] Valid only for STATIC actions.
    dropQuery Boolean
    [bool] Default is false; valid only for REDIRECT actions.
    location String
    [string] The location for redirecting; mandatory and valid only for REDIRECT actions.
    responseMessage String
    [string] The response message of the request; mandatory for STATIC action.
    statusCode Double
    [int] Valid only for REDIRECT and STATIC actions. For REDIRECT actions, default is 301 and possible values are 301, 302, 303, 307, and 308. For STATIC actions, default is 503 and valid range is 200 to 599.
    targetGroup String
    [string] The UUID of the target group; mandatory for FORWARD action.
    name string
    [string] The unique name of the Application Load Balancer HTTP rule.
    type string
    [string] Type of the Http Rule.
    conditions ApplicationLoadbalancerForwardingruleHttpRuleCondition[]
    [list] - An array of items in the collection.The action is only performed if each and every condition is met; if no conditions are set, the rule will always be performed.
    contentType string
    [string] Valid only for STATIC actions.
    dropQuery boolean
    [bool] Default is false; valid only for REDIRECT actions.
    location string
    [string] The location for redirecting; mandatory and valid only for REDIRECT actions.
    responseMessage string
    [string] The response message of the request; mandatory for STATIC action.
    statusCode number
    [int] Valid only for REDIRECT and STATIC actions. For REDIRECT actions, default is 301 and possible values are 301, 302, 303, 307, and 308. For STATIC actions, default is 503 and valid range is 200 to 599.
    targetGroup string
    [string] The UUID of the target group; mandatory for FORWARD action.
    name str
    [string] The unique name of the Application Load Balancer HTTP rule.
    type str
    [string] Type of the Http Rule.
    conditions Sequence[ApplicationLoadbalancerForwardingruleHttpRuleCondition]
    [list] - An array of items in the collection.The action is only performed if each and every condition is met; if no conditions are set, the rule will always be performed.
    content_type str
    [string] Valid only for STATIC actions.
    drop_query bool
    [bool] Default is false; valid only for REDIRECT actions.
    location str
    [string] The location for redirecting; mandatory and valid only for REDIRECT actions.
    response_message str
    [string] The response message of the request; mandatory for STATIC action.
    status_code float
    [int] Valid only for REDIRECT and STATIC actions. For REDIRECT actions, default is 301 and possible values are 301, 302, 303, 307, and 308. For STATIC actions, default is 503 and valid range is 200 to 599.
    target_group str
    [string] The UUID of the target group; mandatory for FORWARD action.
    name String
    [string] The unique name of the Application Load Balancer HTTP rule.
    type String
    [string] Type of the Http Rule.
    conditions List<Property Map>
    [list] - An array of items in the collection.The action is only performed if each and every condition is met; if no conditions are set, the rule will always be performed.
    contentType String
    [string] Valid only for STATIC actions.
    dropQuery Boolean
    [bool] Default is false; valid only for REDIRECT actions.
    location String
    [string] The location for redirecting; mandatory and valid only for REDIRECT actions.
    responseMessage String
    [string] The response message of the request; mandatory for STATIC action.
    statusCode Number
    [int] Valid only for REDIRECT and STATIC actions. For REDIRECT actions, default is 301 and possible values are 301, 302, 303, 307, and 308. For STATIC actions, default is 503 and valid range is 200 to 599.
    targetGroup String
    [string] The UUID of the target group; mandatory for FORWARD action.

    ApplicationLoadbalancerForwardingruleHttpRuleCondition, ApplicationLoadbalancerForwardingruleHttpRuleConditionArgs

    Type string
    [string] Type of the Http Rule condition.
    Condition string
    [string] Matching rule for the HTTP rule condition attribute; mandatory for HEADER, PATH, QUERY, METHOD, HOST, and COOKIE types; must be null when type is SOURCE_IP.
    Key string
    [string] Must be null when type is PATH, METHOD, HOST, or SOURCE_IP. Key can only be set when type is COOKIES, HEADER, or QUERY.
    Negate bool
    [bool] Specifies whether the condition is negated or not; the default is False.
    Value string
    [string] Mandatory for conditions CONTAINS, EQUALS, MATCHES, STARTS_WITH, ENDS_WITH; must be null when condition is EXISTS; should be a valid CIDR if provided and if type is SOURCE_IP.
    Type string
    [string] Type of the Http Rule condition.
    Condition string
    [string] Matching rule for the HTTP rule condition attribute; mandatory for HEADER, PATH, QUERY, METHOD, HOST, and COOKIE types; must be null when type is SOURCE_IP.
    Key string
    [string] Must be null when type is PATH, METHOD, HOST, or SOURCE_IP. Key can only be set when type is COOKIES, HEADER, or QUERY.
    Negate bool
    [bool] Specifies whether the condition is negated or not; the default is False.
    Value string
    [string] Mandatory for conditions CONTAINS, EQUALS, MATCHES, STARTS_WITH, ENDS_WITH; must be null when condition is EXISTS; should be a valid CIDR if provided and if type is SOURCE_IP.
    type String
    [string] Type of the Http Rule condition.
    condition String
    [string] Matching rule for the HTTP rule condition attribute; mandatory for HEADER, PATH, QUERY, METHOD, HOST, and COOKIE types; must be null when type is SOURCE_IP.
    key String
    [string] Must be null when type is PATH, METHOD, HOST, or SOURCE_IP. Key can only be set when type is COOKIES, HEADER, or QUERY.
    negate Boolean
    [bool] Specifies whether the condition is negated or not; the default is False.
    value String
    [string] Mandatory for conditions CONTAINS, EQUALS, MATCHES, STARTS_WITH, ENDS_WITH; must be null when condition is EXISTS; should be a valid CIDR if provided and if type is SOURCE_IP.
    type string
    [string] Type of the Http Rule condition.
    condition string
    [string] Matching rule for the HTTP rule condition attribute; mandatory for HEADER, PATH, QUERY, METHOD, HOST, and COOKIE types; must be null when type is SOURCE_IP.
    key string
    [string] Must be null when type is PATH, METHOD, HOST, or SOURCE_IP. Key can only be set when type is COOKIES, HEADER, or QUERY.
    negate boolean
    [bool] Specifies whether the condition is negated or not; the default is False.
    value string
    [string] Mandatory for conditions CONTAINS, EQUALS, MATCHES, STARTS_WITH, ENDS_WITH; must be null when condition is EXISTS; should be a valid CIDR if provided and if type is SOURCE_IP.
    type str
    [string] Type of the Http Rule condition.
    condition str
    [string] Matching rule for the HTTP rule condition attribute; mandatory for HEADER, PATH, QUERY, METHOD, HOST, and COOKIE types; must be null when type is SOURCE_IP.
    key str
    [string] Must be null when type is PATH, METHOD, HOST, or SOURCE_IP. Key can only be set when type is COOKIES, HEADER, or QUERY.
    negate bool
    [bool] Specifies whether the condition is negated or not; the default is False.
    value str
    [string] Mandatory for conditions CONTAINS, EQUALS, MATCHES, STARTS_WITH, ENDS_WITH; must be null when condition is EXISTS; should be a valid CIDR if provided and if type is SOURCE_IP.
    type String
    [string] Type of the Http Rule condition.
    condition String
    [string] Matching rule for the HTTP rule condition attribute; mandatory for HEADER, PATH, QUERY, METHOD, HOST, and COOKIE types; must be null when type is SOURCE_IP.
    key String
    [string] Must be null when type is PATH, METHOD, HOST, or SOURCE_IP. Key can only be set when type is COOKIES, HEADER, or QUERY.
    negate Boolean
    [bool] Specifies whether the condition is negated or not; the default is False.
    value String
    [string] Mandatory for conditions CONTAINS, EQUALS, MATCHES, STARTS_WITH, ENDS_WITH; must be null when condition is EXISTS; should be a valid CIDR if provided and if type is SOURCE_IP.

    ApplicationLoadbalancerForwardingruleTimeouts, ApplicationLoadbalancerForwardingruleTimeoutsArgs

    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

    Resource Application Load Balancer Forwarding Rule can be imported using the resource id, alb id and datacenter id, e.g.

    $ pulumi import ionoscloud:index/applicationLoadbalancerForwardingrule:ApplicationLoadbalancerForwardingrule my_application_loadbalancer_forwardingrule datacenter uuid/application_loadbalancer uuid/application_loadbalancer_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