alicloud.alb.getRules

import * as pulumi from "@pulumi/pulumi";
import * as alicloud from "@pulumi/alicloud";
import * as std from "@pulumi/std";

const config = new pulumi.Config();
const name = config.get("name") || "tf-example";
const _default = alicloud.alb.getZones({});
const defaultGetResourceGroups = alicloud.resourcemanager.getResourceGroups({});
const defaultNetwork = new alicloud.vpc.Network("default", {
    vpcName: name,
    cidrBlock: "10.4.0.0/16",
});
const defaultSwitch: alicloud.vpc.Switch[] = [];
for (const range = {value: 0}; range.value < 2; range.value++) {
    defaultSwitch.push(new alicloud.vpc.Switch(`default-${range.value}`, {
        vpcId: defaultNetwork.id,
        cidrBlock: std.format({
            input: "10.4.%d.0/24",
            args: [range.value + 1],
        }).then(invoke => invoke.result),
        zoneId: _default.then(_default => _default.zones[range.value].id),
        vswitchName: std.format({
            input: `${name}_%d`,
            args: [range.value + 1],
        }).then(invoke => invoke.result),
    }));
}
const defaultLoadBalancer = new alicloud.alb.LoadBalancer("default", {
    vpcId: defaultNetwork.id,
    addressType: "Internet",
    addressAllocatedMode: "Fixed",
    loadBalancerName: name,
    loadBalancerEdition: "Standard",
    resourceGroupId: defaultGetResourceGroups.then(defaultGetResourceGroups => defaultGetResourceGroups.groups?.[0]?.id),
    loadBalancerBillingConfig: {
        payType: "PayAsYouGo",
    },
    tags: {
        Created: "TF",
    },
    zoneMappings: [
        {
            vswitchId: defaultSwitch[0].id,
            zoneId: _default.then(_default => _default.zones?.[0]?.id),
        },
        {
            vswitchId: defaultSwitch[1].id,
            zoneId: _default.then(_default => _default.zones?.[1]?.id),
        },
    ],
});
const defaultServerGroup = new alicloud.alb.ServerGroup("default", {
    protocol: "HTTP",
    vpcId: defaultNetwork.id,
    serverGroupName: name,
    resourceGroupId: defaultGetResourceGroups.then(defaultGetResourceGroups => defaultGetResourceGroups.groups?.[0]?.id),
    healthCheckConfig: {
        healthCheckEnabled: false,
    },
    stickySessionConfig: {
        stickySessionEnabled: false,
    },
    tags: {
        Created: "TF",
    },
});
const defaultListener = new alicloud.alb.Listener("default", {
    loadBalancerId: defaultLoadBalancer.id,
    listenerProtocol: "HTTP",
    listenerPort: 80,
    listenerDescription: name,
    defaultActions: [{
        type: "ForwardGroup",
        forwardGroupConfig: {
            serverGroupTuples: [{
                serverGroupId: defaultServerGroup.id,
            }],
        },
    }],
});
const defaultRule = new alicloud.alb.Rule("default", {
    ruleName: name,
    listenerId: defaultListener.id,
    priority: 555,
    ruleConditions: [{
        cookieConfig: {
            values: [{
                key: "created",
                value: "tf",
            }],
        },
        type: "Cookie",
    }],
    ruleActions: [{
        forwardGroupConfig: {
            serverGroupTuples: [{
                serverGroupId: defaultServerGroup.id,
            }],
        },
        order: 9,
        type: "ForwardGroup",
    }],
});
const ids = alicloud.alb.getRulesOutput({
    ids: [defaultRule.id],
});
export const albRuleId = ids.apply(ids => ids.rules?.[0]?.id);

import pulumi
import pulumi_alicloud as alicloud
import pulumi_std as std

config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "tf-example"
default = alicloud.alb.get_zones()
default_get_resource_groups = alicloud.resourcemanager.get_resource_groups()
default_network = alicloud.vpc.Network("default",
    vpc_name=name,
    cidr_block="10.4.0.0/16")
default_switch = []
for range in [{"value": i} for i in range(0, 2)]:
    default_switch.append(alicloud.vpc.Switch(f"default-{range['value']}",
        vpc_id=default_network.id,
        cidr_block=std.format(input="10.4.%d.0/24",
            args=[range["value"] + 1]).result,
        zone_id=default.zones[range["value"]].id,
        vswitch_name=std.format(input=f"{name}_%d",
            args=[range["value"] + 1]).result))
default_load_balancer = alicloud.alb.LoadBalancer("default",
    vpc_id=default_network.id,
    address_type="Internet",
    address_allocated_mode="Fixed",
    load_balancer_name=name,
    load_balancer_edition="Standard",
    resource_group_id=default_get_resource_groups.groups[0].id,
    load_balancer_billing_config={
        "pay_type": "PayAsYouGo",
    },
    tags={
        "Created": "TF",
    },
    zone_mappings=[
        {
            "vswitch_id": default_switch[0].id,
            "zone_id": default.zones[0].id,
        },
        {
            "vswitch_id": default_switch[1].id,
            "zone_id": default.zones[1].id,
        },
    ])
default_server_group = alicloud.alb.ServerGroup("default",
    protocol="HTTP",
    vpc_id=default_network.id,
    server_group_name=name,
    resource_group_id=default_get_resource_groups.groups[0].id,
    health_check_config={
        "health_check_enabled": False,
    },
    sticky_session_config={
        "sticky_session_enabled": False,
    },
    tags={
        "Created": "TF",
    })
default_listener = alicloud.alb.Listener("default",
    load_balancer_id=default_load_balancer.id,
    listener_protocol="HTTP",
    listener_port=80,
    listener_description=name,
    default_actions=[{
        "type": "ForwardGroup",
        "forward_group_config": {
            "server_group_tuples": [{
                "server_group_id": default_server_group.id,
            }],
        },
    }])
default_rule = alicloud.alb.Rule("default",
    rule_name=name,
    listener_id=default_listener.id,
    priority=555,
    rule_conditions=[{
        "cookie_config": {
            "values": [{
                "key": "created",
                "value": "tf",
            }],
        },
        "type": "Cookie",
    }],
    rule_actions=[{
        "forward_group_config": {
            "server_group_tuples": [{
                "server_group_id": default_server_group.id,
            }],
        },
        "order": 9,
        "type": "ForwardGroup",
    }])
ids = alicloud.alb.get_rules_output(ids=[default_rule.id])
pulumi.export("albRuleId", ids.rules[0].id)

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/alb"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/resourcemanager"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/vpc"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		name := "tf-example"
		if param := cfg.Get("name"); param != "" {
			name = param
		}
		_default, err := alb.GetZones(ctx, &alb.GetZonesArgs{}, nil)
		if err != nil {
			return err
		}
		defaultGetResourceGroups, err := resourcemanager.GetResourceGroups(ctx, &resourcemanager.GetResourceGroupsArgs{}, nil)
		if err != nil {
			return err
		}
		defaultNetwork, err := vpc.NewNetwork(ctx, "default", &vpc.NetworkArgs{
			VpcName:   pulumi.String(name),
			CidrBlock: pulumi.String("10.4.0.0/16"),
		})
		if err != nil {
			return err
		}
		invokeFormat, err := std.Format(ctx, &std.FormatArgs{
			Input: "10.4.%d.0/24",
			Args: []float64{
				val0 + 1,
			},
		}, nil)
		if err != nil {
			return err
		}
		invokeFormat1, err := std.Format(ctx, &std.FormatArgs{
			Input: fmt.Sprintf("%v%v", name, "_%d"),
			Args: []float64{
				val0 + 1,
			},
		}, nil)
		if err != nil {
			return err
		}
		var defaultSwitch []*vpc.Switch
		for index := 0; index < 2; index++ {
			key0 := index
			val0 := index
			__res, err := vpc.NewSwitch(ctx, fmt.Sprintf("default-%v", key0), &vpc.SwitchArgs{
				VpcId:       defaultNetwork.ID(),
				CidrBlock:   pulumi.String(invokeFormat.Result),
				ZoneId:      _default.Zones[val0].Id,
				VswitchName: pulumi.String(invokeFormat1.Result),
			})
			if err != nil {
				return err
			}
			defaultSwitch = append(defaultSwitch, __res)
		}
		defaultLoadBalancer, err := alb.NewLoadBalancer(ctx, "default", &alb.LoadBalancerArgs{
			VpcId:                defaultNetwork.ID(),
			AddressType:          pulumi.String("Internet"),
			AddressAllocatedMode: pulumi.String("Fixed"),
			LoadBalancerName:     pulumi.String(name),
			LoadBalancerEdition:  pulumi.String("Standard"),
			ResourceGroupId:      pulumi.String(defaultGetResourceGroups.Groups[0].Id),
			LoadBalancerBillingConfig: &alb.LoadBalancerLoadBalancerBillingConfigArgs{
				PayType: pulumi.String("PayAsYouGo"),
			},
			Tags: pulumi.StringMap{
				"Created": pulumi.String("TF"),
			},
			ZoneMappings: alb.LoadBalancerZoneMappingArray{
				&alb.LoadBalancerZoneMappingArgs{
					VswitchId: defaultSwitch[0].ID(),
					ZoneId:    pulumi.String(_default.Zones[0].Id),
				},
				&alb.LoadBalancerZoneMappingArgs{
					VswitchId: defaultSwitch[1].ID(),
					ZoneId:    pulumi.String(_default.Zones[1].Id),
				},
			},
		})
		if err != nil {
			return err
		}
		defaultServerGroup, err := alb.NewServerGroup(ctx, "default", &alb.ServerGroupArgs{
			Protocol:        pulumi.String("HTTP"),
			VpcId:           defaultNetwork.ID(),
			ServerGroupName: pulumi.String(name),
			ResourceGroupId: pulumi.String(defaultGetResourceGroups.Groups[0].Id),
			HealthCheckConfig: &alb.ServerGroupHealthCheckConfigArgs{
				HealthCheckEnabled: pulumi.Bool(false),
			},
			StickySessionConfig: &alb.ServerGroupStickySessionConfigArgs{
				StickySessionEnabled: pulumi.Bool(false),
			},
			Tags: pulumi.StringMap{
				"Created": pulumi.String("TF"),
			},
		})
		if err != nil {
			return err
		}
		defaultListener, err := alb.NewListener(ctx, "default", &alb.ListenerArgs{
			LoadBalancerId:      defaultLoadBalancer.ID(),
			ListenerProtocol:    pulumi.String("HTTP"),
			ListenerPort:        pulumi.Int(80),
			ListenerDescription: pulumi.String(name),
			DefaultActions: alb.ListenerDefaultActionArray{
				&alb.ListenerDefaultActionArgs{
					Type: pulumi.String("ForwardGroup"),
					ForwardGroupConfig: &alb.ListenerDefaultActionForwardGroupConfigArgs{
						ServerGroupTuples: alb.ListenerDefaultActionForwardGroupConfigServerGroupTupleArray{
							&alb.ListenerDefaultActionForwardGroupConfigServerGroupTupleArgs{
								ServerGroupId: defaultServerGroup.ID(),
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		defaultRule, err := alb.NewRule(ctx, "default", &alb.RuleArgs{
			RuleName:   pulumi.String(name),
			ListenerId: defaultListener.ID(),
			Priority:   pulumi.Int(555),
			RuleConditions: alb.RuleRuleConditionArray{
				&alb.RuleRuleConditionArgs{
					CookieConfig: &alb.RuleRuleConditionCookieConfigArgs{
						Values: alb.RuleRuleConditionCookieConfigValueArray{
							&alb.RuleRuleConditionCookieConfigValueArgs{
								Key:   pulumi.String("created"),
								Value: pulumi.String("tf"),
							},
						},
					},
					Type: pulumi.String("Cookie"),
				},
			},
			RuleActions: alb.RuleRuleActionArray{
				&alb.RuleRuleActionArgs{
					ForwardGroupConfig: &alb.RuleRuleActionForwardGroupConfigArgs{
						ServerGroupTuples: alb.RuleRuleActionForwardGroupConfigServerGroupTupleArray{
							&alb.RuleRuleActionForwardGroupConfigServerGroupTupleArgs{
								ServerGroupId: defaultServerGroup.ID(),
							},
						},
					},
					Order: pulumi.Int(9),
					Type:  pulumi.String("ForwardGroup"),
				},
			},
		})
		if err != nil {
			return err
		}
		ids := alb.GetRulesOutput(ctx, alb.GetRulesOutputArgs{
			Ids: pulumi.StringArray{
				defaultRule.ID(),
			},
		}, nil)
		ctx.Export("albRuleId", ids.ApplyT(func(ids alb.GetRulesResult) (*string, error) {
			return &ids.Rules[0].Id, nil
		}).(pulumi.StringPtrOutput))
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AliCloud = Pulumi.AliCloud;
using Std = Pulumi.Std;

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var name = config.Get("name") ?? "tf-example";
    var @default = AliCloud.Alb.GetZones.Invoke();

    var defaultGetResourceGroups = AliCloud.ResourceManager.GetResourceGroups.Invoke();

    var defaultNetwork = new AliCloud.Vpc.Network("default", new()
    {
        VpcName = name,
        CidrBlock = "10.4.0.0/16",
    });

    var defaultSwitch = new List<AliCloud.Vpc.Switch>();
    for (var rangeIndex = 0; rangeIndex < 2; rangeIndex++)
    {
        var range = new { Value = rangeIndex };
        defaultSwitch.Add(new AliCloud.Vpc.Switch($"default-{range.Value}", new()
        {
            VpcId = defaultNetwork.Id,
            CidrBlock = Std.Format.Invoke(new()
            {
                Input = "10.4.%d.0/24",
                Args = new[]
                {
                    range.Value + 1,
                },
            }).Apply(invoke => invoke.Result),
            ZoneId = @default.Apply(@default => @default.Apply(getZonesResult => getZonesResult.Zones)[range.Value].Id),
            VswitchName = Std.Format.Invoke(new()
            {
                Input = $"{name}_%d",
                Args = new[]
                {
                    range.Value + 1,
                },
            }).Apply(invoke => invoke.Result),
        }));
    }
    var defaultLoadBalancer = new AliCloud.Alb.LoadBalancer("default", new()
    {
        VpcId = defaultNetwork.Id,
        AddressType = "Internet",
        AddressAllocatedMode = "Fixed",
        LoadBalancerName = name,
        LoadBalancerEdition = "Standard",
        ResourceGroupId = defaultGetResourceGroups.Apply(getResourceGroupsResult => getResourceGroupsResult.Groups[0]?.Id),
        LoadBalancerBillingConfig = new AliCloud.Alb.Inputs.LoadBalancerLoadBalancerBillingConfigArgs
        {
            PayType = "PayAsYouGo",
        },
        Tags = 
        {
            { "Created", "TF" },
        },
        ZoneMappings = new[]
        {
            new AliCloud.Alb.Inputs.LoadBalancerZoneMappingArgs
            {
                VswitchId = defaultSwitch[0].Id,
                ZoneId = @default.Apply(@default => @default.Apply(getZonesResult => getZonesResult.Zones[0]?.Id)),
            },
            new AliCloud.Alb.Inputs.LoadBalancerZoneMappingArgs
            {
                VswitchId = defaultSwitch[1].Id,
                ZoneId = @default.Apply(@default => @default.Apply(getZonesResult => getZonesResult.Zones[1]?.Id)),
            },
        },
    });

    var defaultServerGroup = new AliCloud.Alb.ServerGroup("default", new()
    {
        Protocol = "HTTP",
        VpcId = defaultNetwork.Id,
        ServerGroupName = name,
        ResourceGroupId = defaultGetResourceGroups.Apply(getResourceGroupsResult => getResourceGroupsResult.Groups[0]?.Id),
        HealthCheckConfig = new AliCloud.Alb.Inputs.ServerGroupHealthCheckConfigArgs
        {
            HealthCheckEnabled = false,
        },
        StickySessionConfig = new AliCloud.Alb.Inputs.ServerGroupStickySessionConfigArgs
        {
            StickySessionEnabled = false,
        },
        Tags = 
        {
            { "Created", "TF" },
        },
    });

    var defaultListener = new AliCloud.Alb.Listener("default", new()
    {
        LoadBalancerId = defaultLoadBalancer.Id,
        ListenerProtocol = "HTTP",
        ListenerPort = 80,
        ListenerDescription = name,
        DefaultActions = new[]
        {
            new AliCloud.Alb.Inputs.ListenerDefaultActionArgs
            {
                Type = "ForwardGroup",
                ForwardGroupConfig = new AliCloud.Alb.Inputs.ListenerDefaultActionForwardGroupConfigArgs
                {
                    ServerGroupTuples = new[]
                    {
                        new AliCloud.Alb.Inputs.ListenerDefaultActionForwardGroupConfigServerGroupTupleArgs
                        {
                            ServerGroupId = defaultServerGroup.Id,
                        },
                    },
                },
            },
        },
    });

    var defaultRule = new AliCloud.Alb.Rule("default", new()
    {
        RuleName = name,
        ListenerId = defaultListener.Id,
        Priority = 555,
        RuleConditions = new[]
        {
            new AliCloud.Alb.Inputs.RuleRuleConditionArgs
            {
                CookieConfig = new AliCloud.Alb.Inputs.RuleRuleConditionCookieConfigArgs
                {
                    Values = new[]
                    {
                        new AliCloud.Alb.Inputs.RuleRuleConditionCookieConfigValueArgs
                        {
                            Key = "created",
                            Value = "tf",
                        },
                    },
                },
                Type = "Cookie",
            },
        },
        RuleActions = new[]
        {
            new AliCloud.Alb.Inputs.RuleRuleActionArgs
            {
                ForwardGroupConfig = new AliCloud.Alb.Inputs.RuleRuleActionForwardGroupConfigArgs
                {
                    ServerGroupTuples = new[]
                    {
                        new AliCloud.Alb.Inputs.RuleRuleActionForwardGroupConfigServerGroupTupleArgs
                        {
                            ServerGroupId = defaultServerGroup.Id,
                        },
                    },
                },
                Order = 9,
                Type = "ForwardGroup",
            },
        },
    });

    var ids = AliCloud.Alb.GetRules.Invoke(new()
    {
        Ids = new[]
        {
            defaultRule.Id,
        },
    });

    return new Dictionary<string, object?>
    {
        ["albRuleId"] = ids.Apply(getRulesResult => getRulesResult.Rules[0]?.Id),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.alicloud.alb.AlbFunctions;
import com.pulumi.alicloud.alb.inputs.GetZonesArgs;
import com.pulumi.alicloud.resourcemanager.ResourcemanagerFunctions;
import com.pulumi.alicloud.resourcemanager.inputs.GetResourceGroupsArgs;
import com.pulumi.alicloud.vpc.Network;
import com.pulumi.alicloud.vpc.NetworkArgs;
import com.pulumi.alicloud.vpc.Switch;
import com.pulumi.alicloud.vpc.SwitchArgs;
import com.pulumi.std.StdFunctions;
import com.pulumi.std.inputs.FormatArgs;
import com.pulumi.alicloud.alb.LoadBalancer;
import com.pulumi.alicloud.alb.LoadBalancerArgs;
import com.pulumi.alicloud.alb.inputs.LoadBalancerLoadBalancerBillingConfigArgs;
import com.pulumi.alicloud.alb.inputs.LoadBalancerZoneMappingArgs;
import com.pulumi.alicloud.alb.ServerGroup;
import com.pulumi.alicloud.alb.ServerGroupArgs;
import com.pulumi.alicloud.alb.inputs.ServerGroupHealthCheckConfigArgs;
import com.pulumi.alicloud.alb.inputs.ServerGroupStickySessionConfigArgs;
import com.pulumi.alicloud.alb.Listener;
import com.pulumi.alicloud.alb.ListenerArgs;
import com.pulumi.alicloud.alb.inputs.ListenerDefaultActionArgs;
import com.pulumi.alicloud.alb.inputs.ListenerDefaultActionForwardGroupConfigArgs;
import com.pulumi.alicloud.alb.Rule;
import com.pulumi.alicloud.alb.RuleArgs;
import com.pulumi.alicloud.alb.inputs.RuleRuleConditionArgs;
import com.pulumi.alicloud.alb.inputs.RuleRuleConditionCookieConfigArgs;
import com.pulumi.alicloud.alb.inputs.RuleRuleActionArgs;
import com.pulumi.alicloud.alb.inputs.RuleRuleActionForwardGroupConfigArgs;
import com.pulumi.alicloud.alb.inputs.GetRulesArgs;
import com.pulumi.codegen.internal.KeyedValue;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        final var config = ctx.config();
        final var name = config.get("name").orElse("tf-example");
        final var default = AlbFunctions.getZones(GetZonesArgs.builder()
            .build());

        final var defaultGetResourceGroups = ResourcemanagerFunctions.getResourceGroups(GetResourceGroupsArgs.builder()
            .build());

        var defaultNetwork = new Network("defaultNetwork", NetworkArgs.builder()
            .vpcName(name)
            .cidrBlock("10.4.0.0/16")
            .build());

        for (var i = 0; i < 2; i++) {
            new Switch("defaultSwitch-" + i, SwitchArgs.builder()
                .vpcId(defaultNetwork.id())
                .cidrBlock(StdFunctions.format(FormatArgs.builder()
                    .input("10.4.%d.0/24")
                    .args(range.value() + 1)
                    .build()).result())
                .zoneId(default_.zones()[range.value()].id())
                .vswitchName(StdFunctions.format(FormatArgs.builder()
                    .input(String.format("%s_%d", name))
                    .args(range.value() + 1)
                    .build()).result())
                .build());

        
}
        var defaultLoadBalancer = new LoadBalancer("defaultLoadBalancer", LoadBalancerArgs.builder()
            .vpcId(defaultNetwork.id())
            .addressType("Internet")
            .addressAllocatedMode("Fixed")
            .loadBalancerName(name)
            .loadBalancerEdition("Standard")
            .resourceGroupId(defaultGetResourceGroups.groups()[0].id())
            .loadBalancerBillingConfig(LoadBalancerLoadBalancerBillingConfigArgs.builder()
                .payType("PayAsYouGo")
                .build())
            .tags(Map.of("Created", "TF"))
            .zoneMappings(            
                LoadBalancerZoneMappingArgs.builder()
                    .vswitchId(defaultSwitch[0].id())
                    .zoneId(default_.zones()[0].id())
                    .build(),
                LoadBalancerZoneMappingArgs.builder()
                    .vswitchId(defaultSwitch[1].id())
                    .zoneId(default_.zones()[1].id())
                    .build())
            .build());

        var defaultServerGroup = new ServerGroup("defaultServerGroup", ServerGroupArgs.builder()
            .protocol("HTTP")
            .vpcId(defaultNetwork.id())
            .serverGroupName(name)
            .resourceGroupId(defaultGetResourceGroups.groups()[0].id())
            .healthCheckConfig(ServerGroupHealthCheckConfigArgs.builder()
                .healthCheckEnabled(false)
                .build())
            .stickySessionConfig(ServerGroupStickySessionConfigArgs.builder()
                .stickySessionEnabled(false)
                .build())
            .tags(Map.of("Created", "TF"))
            .build());

        var defaultListener = new Listener("defaultListener", ListenerArgs.builder()
            .loadBalancerId(defaultLoadBalancer.id())
            .listenerProtocol("HTTP")
            .listenerPort(80)
            .listenerDescription(name)
            .defaultActions(ListenerDefaultActionArgs.builder()
                .type("ForwardGroup")
                .forwardGroupConfig(ListenerDefaultActionForwardGroupConfigArgs.builder()
                    .serverGroupTuples(ListenerDefaultActionForwardGroupConfigServerGroupTupleArgs.builder()
                        .serverGroupId(defaultServerGroup.id())
                        .build())
                    .build())
                .build())
            .build());

        var defaultRule = new Rule("defaultRule", RuleArgs.builder()
            .ruleName(name)
            .listenerId(defaultListener.id())
            .priority(555)
            .ruleConditions(RuleRuleConditionArgs.builder()
                .cookieConfig(RuleRuleConditionCookieConfigArgs.builder()
                    .values(RuleRuleConditionCookieConfigValueArgs.builder()
                        .key("created")
                        .value("tf")
                        .build())
                    .build())
                .type("Cookie")
                .build())
            .ruleActions(RuleRuleActionArgs.builder()
                .forwardGroupConfig(RuleRuleActionForwardGroupConfigArgs.builder()
                    .serverGroupTuples(RuleRuleActionForwardGroupConfigServerGroupTupleArgs.builder()
                        .serverGroupId(defaultServerGroup.id())
                        .build())
                    .build())
                .order(9)
                .type("ForwardGroup")
                .build())
            .build());

        final var ids = AlbFunctions.getRules(GetRulesArgs.builder()
            .ids(defaultRule.id())
            .build());

        ctx.export("albRuleId", ids.applyValue(_ids -> _ids.rules()[0].id()));
    }
}

function getRules(args: GetRulesArgs, opts?: InvokeOptions): Promise<GetRulesResult>
function getRulesOutput(args: GetRulesOutputArgs, opts?: InvokeOptions): Output<GetRulesResult>

def get_rules(ids: Optional[Sequence[str]] = None,
              listener_ids: Optional[Sequence[str]] = None,
              load_balancer_ids: Optional[Sequence[str]] = None,
              name_regex: Optional[str] = None,
              output_file: Optional[str] = None,
              rule_ids: Optional[Sequence[str]] = None,
              status: Optional[str] = None,
              opts: Optional[InvokeOptions] = None) -> GetRulesResult
def get_rules_output(ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
              listener_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
              load_balancer_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
              name_regex: Optional[pulumi.Input[str]] = None,
              output_file: Optional[pulumi.Input[str]] = None,
              rule_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
              status: Optional[pulumi.Input[str]] = None,
              opts: Optional[InvokeOptions] = None) -> Output[GetRulesResult]

func GetRules(ctx *Context, args *GetRulesArgs, opts ...InvokeOption) (*GetRulesResult, error)
func GetRulesOutput(ctx *Context, args *GetRulesOutputArgs, opts ...InvokeOption) GetRulesResultOutput

public static class GetRules 
{
    public static Task<GetRulesResult> InvokeAsync(GetRulesArgs args, InvokeOptions? opts = null)
    public static Output<GetRulesResult> Invoke(GetRulesInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetRulesResult> getRules(GetRulesArgs args, InvokeOptions options)
public static Output<GetRulesResult> getRules(GetRulesArgs args, InvokeOptions options)

fn::invoke:
  function: alicloud:alb/getRules:getRules
  arguments:
    # arguments dictionary