pulumi-alicloud-kotlin/com.pulumi.alicloud.alb.kotlin/AlbFunctions/getLoadBalancers

getLoadBalancers

suspend fun getLoadBalancers(argument: GetLoadBalancersPlainArgs): GetLoadBalancersResult

This data source provides the Alb Load Balancers of the current Alibaba Cloud user.

NOTE: Available since v1.132.0.

Example Usage

Basic Usage

import * as pulumi from "@pulumi/pulumi";
import * as alicloud from "@pulumi/alicloud";
const config = new pulumi.Config();
const name = config.get("name") || "terraform-example";
const _default = alicloud.resourcemanager.getResourceGroups({});
const defaultGetZones = alicloud.alb.getZones({});
const defaultNetwork = new alicloud.vpc.Network("default", {
    vpcName: name,
    cidrBlock: "192.168.0.0/16",
    enableIpv6: true,
});
const zoneA = new alicloud.ecs.Eip("zone_a", {
    bandwidth: "10",
    internetChargeType: "PayByTraffic",
});
const zoneASwitch = new alicloud.vpc.Switch("zone_a", {
    vswitchName: name,
    vpcId: defaultNetwork.id,
    cidrBlock: "192.168.0.0/18",
    zoneId: defaultGetZones.then(defaultGetZones => defaultGetZones.zones?.[0]?.id),
    ipv6CidrBlockMask: 6,
});
const zoneB = new alicloud.vpc.Switch("zone_b", {
    vswitchName: name,
    vpcId: defaultNetwork.id,
    cidrBlock: "192.168.128.0/18",
    zoneId: defaultGetZones.then(defaultGetZones => defaultGetZones.zones?.[1]?.id),
    ipv6CidrBlockMask: 8,
});
const defaultIpv6Gateway = new alicloud.vpc.Ipv6Gateway("default", {
    ipv6GatewayName: name,
    vpcId: defaultNetwork.id,
});
const defaultCommonBandwithPackage = new alicloud.vpc.CommonBandwithPackage("default", {
    bandwidth: "1000",
    internetChargeType: "PayByBandwidth",
});
const defaultLoadBalancer = new alicloud.alb.LoadBalancer("default", {
    loadBalancerEdition: "Basic",
    addressType: "Internet",
    vpcId: defaultIpv6Gateway.vpcId,
    addressAllocatedMode: "Fixed",
    addressIpVersion: "DualStack",
    ipv6AddressType: "Internet",
    bandwidthPackageId: defaultCommonBandwithPackage.id,
    resourceGroupId: _default.then(_default => _default.groups?.[1]?.id),
    loadBalancerName: name,
    deletionProtectionEnabled: false,
    loadBalancerBillingConfig: {
        payType: "PayAsYouGo",
    },
    zoneMappings: [
        {
            vswitchId: zoneASwitch.id,
            zoneId: zoneASwitch.zoneId,
            eipType: "Common",
            allocationId: zoneA.id,
            intranetAddress: "192.168.10.1",
        },
        {
            vswitchId: zoneB.id,
            zoneId: zoneB.zoneId,
        },
    ],
    tags: {
        Created: "TF",
    },
});
const ids = alicloud.alb.getLoadBalancersOutput({
    ids: [defaultLoadBalancer.id],
});
export const albLoadBalancersId0 = ids.apply(ids => ids.balancers?.[0]?.id);
Content copied to clipboard
import pulumi
import pulumi_alicloud as alicloud
config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "terraform-example"
default = alicloud.resourcemanager.get_resource_groups()
default_get_zones = alicloud.alb.get_zones()
default_network = alicloud.vpc.Network("default",
    vpc_name=name,
    cidr_block="192.168.0.0/16",
    enable_ipv6=True)
zone_a = alicloud.ecs.Eip("zone_a",
    bandwidth="10",
    internet_charge_type="PayByTraffic")
zone_a_switch = alicloud.vpc.Switch("zone_a",
    vswitch_name=name,
    vpc_id=default_network.id,
    cidr_block="192.168.0.0/18",
    zone_id=default_get_zones.zones[0].id,
    ipv6_cidr_block_mask=6)
zone_b = alicloud.vpc.Switch("zone_b",
    vswitch_name=name,
    vpc_id=default_network.id,
    cidr_block="192.168.128.0/18",
    zone_id=default_get_zones.zones[1].id,
    ipv6_cidr_block_mask=8)
default_ipv6_gateway = alicloud.vpc.Ipv6Gateway("default",
    ipv6_gateway_name=name,
    vpc_id=default_network.id)
default_common_bandwith_package = alicloud.vpc.CommonBandwithPackage("default",
    bandwidth="1000",
    internet_charge_type="PayByBandwidth")
default_load_balancer = alicloud.alb.LoadBalancer("default",
    load_balancer_edition="Basic",
    address_type="Internet",
    vpc_id=default_ipv6_gateway.vpc_id,
    address_allocated_mode="Fixed",
    address_ip_version="DualStack",
    ipv6_address_type="Internet",
    bandwidth_package_id=default_common_bandwith_package.id,
    resource_group_id=default.groups[1].id,
    load_balancer_name=name,
    deletion_protection_enabled=False,
    load_balancer_billing_config={
        "pay_type": "PayAsYouGo",
    },
    zone_mappings=[
        {
            "vswitch_id": zone_a_switch.id,
            "zone_id": zone_a_switch.zone_id,
            "eip_type": "Common",
            "allocation_id": zone_a.id,
            "intranet_address": "192.168.10.1",
        },
        {
            "vswitch_id": zone_b.id,
            "zone_id": zone_b.zone_id,
        },
    ],
    tags={
        "Created": "TF",
    })
ids = alicloud.alb.get_load_balancers_output(ids=[default_load_balancer.id])
pulumi.export("albLoadBalancersId0", ids.balancers[0].id)
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AliCloud = Pulumi.AliCloud;
return await Deployment.RunAsync(() =>
{
    var config = new Config();
    var name = config.Get("name") ?? "terraform-example";
    var @default = AliCloud.ResourceManager.GetResourceGroups.Invoke();
    var defaultGetZones = AliCloud.Alb.GetZones.Invoke();
    var defaultNetwork = new AliCloud.Vpc.Network("default", new()
    {
        VpcName = name,
        CidrBlock = "192.168.0.0/16",
        EnableIpv6 = true,
    });
    var zoneA = new AliCloud.Ecs.Eip("zone_a", new()
    {
        Bandwidth = "10",
        InternetChargeType = "PayByTraffic",
    });
    var zoneASwitch = new AliCloud.Vpc.Switch("zone_a", new()
    {
        VswitchName = name,
        VpcId = defaultNetwork.Id,
        CidrBlock = "192.168.0.0/18",
        ZoneId = defaultGetZones.Apply(getZonesResult => getZonesResult.Zones[0]?.Id),
        Ipv6CidrBlockMask = 6,
    });
    var zoneB = new AliCloud.Vpc.Switch("zone_b", new()
    {
        VswitchName = name,
        VpcId = defaultNetwork.Id,
        CidrBlock = "192.168.128.0/18",
        ZoneId = defaultGetZones.Apply(getZonesResult => getZonesResult.Zones[1]?.Id),
        Ipv6CidrBlockMask = 8,
    });
    var defaultIpv6Gateway = new AliCloud.Vpc.Ipv6Gateway("default", new()
    {
        Ipv6GatewayName = name,
        VpcId = defaultNetwork.Id,
    });
    var defaultCommonBandwithPackage = new AliCloud.Vpc.CommonBandwithPackage("default", new()
    {
        Bandwidth = "1000",
        InternetChargeType = "PayByBandwidth",
    });
    var defaultLoadBalancer = new AliCloud.Alb.LoadBalancer("default", new()
    {
        LoadBalancerEdition = "Basic",
        AddressType = "Internet",
        VpcId = defaultIpv6Gateway.VpcId,
        AddressAllocatedMode = "Fixed",
        AddressIpVersion = "DualStack",
        Ipv6AddressType = "Internet",
        BandwidthPackageId = defaultCommonBandwithPackage.Id,
        ResourceGroupId = @default.Apply(@default => @default.Apply(getResourceGroupsResult => getResourceGroupsResult.Groups[1]?.Id)),
        LoadBalancerName = name,
        DeletionProtectionEnabled = false,
        LoadBalancerBillingConfig = new AliCloud.Alb.Inputs.LoadBalancerLoadBalancerBillingConfigArgs
        {
            PayType = "PayAsYouGo",
        },
        ZoneMappings = new[]
        {
            new AliCloud.Alb.Inputs.LoadBalancerZoneMappingArgs
            {
                VswitchId = zoneASwitch.Id,
                ZoneId = zoneASwitch.ZoneId,
                EipType = "Common",
                AllocationId = zoneA.Id,
                IntranetAddress = "192.168.10.1",
            },
            new AliCloud.Alb.Inputs.LoadBalancerZoneMappingArgs
            {
                VswitchId = zoneB.Id,
                ZoneId = zoneB.ZoneId,
            },
        },
        Tags =
        {
            { "Created", "TF" },
        },
    });
    var ids = AliCloud.Alb.GetLoadBalancers.Invoke(new()
    {
        Ids = new[]
        {
            defaultLoadBalancer.Id,
        },
    });
    return new Dictionary<string, object?>
    {
        ["albLoadBalancersId0"] = ids&#46;Apply(getLoadBalancersResult => getLoadBalancersResult&#46;Balancers[0]?.Id),
    };
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/alb"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/ecs"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/resourcemanager"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/vpc"
	"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 := "terraform-example"
		if param := cfg.Get("name"); param != "" {
			name = param
		}
		_default, err := resourcemanager.GetResourceGroups(ctx, &resourcemanager.GetResourceGroupsArgs{}, nil)
		if err != nil {
			return err
		}
		defaultGetZones, err := alb.GetZones(ctx, &alb.GetZonesArgs{}, nil)
		if err != nil {
			return err
		}
		defaultNetwork, err := vpc.NewNetwork(ctx, "default", &vpc.NetworkArgs{
			VpcName:    pulumi.String(name),
			CidrBlock:  pulumi.String("192.168.0.0/16"),
			EnableIpv6: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		zoneA, err := ecs.NewEip(ctx, "zone_a", &ecs.EipArgs{
			Bandwidth:          pulumi.String("10"),
			InternetChargeType: pulumi.String("PayByTraffic"),
		})
		if err != nil {
			return err
		}
		zoneASwitch, err := vpc.NewSwitch(ctx, "zone_a", &vpc.SwitchArgs{
			VswitchName:       pulumi.String(name),
			VpcId:             defaultNetwork.ID(),
			CidrBlock:         pulumi.String("192.168.0.0/18"),
			ZoneId:            pulumi.String(defaultGetZones.Zones[0].Id),
			Ipv6CidrBlockMask: pulumi.Int(6),
		})
		if err != nil {
			return err
		}
		zoneB, err := vpc.NewSwitch(ctx, "zone_b", &vpc.SwitchArgs{
			VswitchName:       pulumi.String(name),
			VpcId:             defaultNetwork.ID(),
			CidrBlock:         pulumi.String("192.168.128.0/18"),
			ZoneId:            pulumi.String(defaultGetZones.Zones[1].Id),
			Ipv6CidrBlockMask: pulumi.Int(8),
		})
		if err != nil {
			return err
		}
		defaultIpv6Gateway, err := vpc.NewIpv6Gateway(ctx, "default", &vpc.Ipv6GatewayArgs{
			Ipv6GatewayName: pulumi.String(name),
			VpcId:           defaultNetwork.ID(),
		})
		if err != nil {
			return err
		}
		defaultCommonBandwithPackage, err := vpc.NewCommonBandwithPackage(ctx, "default", &vpc.CommonBandwithPackageArgs{
			Bandwidth:          pulumi.String("1000"),
			InternetChargeType: pulumi.String("PayByBandwidth"),
		})
		if err != nil {
			return err
		}
		defaultLoadBalancer, err := alb.NewLoadBalancer(ctx, "default", &alb.LoadBalancerArgs{
			LoadBalancerEdition:       pulumi.String("Basic"),
			AddressType:               pulumi.String("Internet"),
			VpcId:                     defaultIpv6Gateway.VpcId,
			AddressAllocatedMode:      pulumi.String("Fixed"),
			AddressIpVersion:          pulumi.String("DualStack"),
			Ipv6AddressType:           pulumi.String("Internet"),
			BandwidthPackageId:        defaultCommonBandwithPackage.ID(),
			ResourceGroupId:           pulumi.String(_default.Groups[1].Id),
			LoadBalancerName:          pulumi.String(name),
			DeletionProtectionEnabled: pulumi.Bool(false),
			LoadBalancerBillingConfig: &alb.LoadBalancerLoadBalancerBillingConfigArgs{
				PayType: pulumi.String("PayAsYouGo"),
			},
			ZoneMappings: alb.LoadBalancerZoneMappingArray{
				&alb.LoadBalancerZoneMappingArgs{
					VswitchId:       zoneASwitch.ID(),
					ZoneId:          zoneASwitch.ZoneId,
					EipType:         pulumi.String("Common"),
					AllocationId:    zoneA.ID(),
					IntranetAddress: pulumi.String("192.168.10.1"),
				},
				&alb.LoadBalancerZoneMappingArgs{
					VswitchId: zoneB.ID(),
					ZoneId:    zoneB.ZoneId,
				},
			},
			Tags: pulumi.StringMap{
				"Created": pulumi.String("TF"),
			},
		})
		if err != nil {
			return err
		}
		ids := alb.GetLoadBalancersOutput(ctx, alb.GetLoadBalancersOutputArgs{
			Ids: pulumi.StringArray{
				defaultLoadBalancer.ID(),
			},
		}, nil)
		ctx.Export("albLoadBalancersId0", ids.ApplyT(func(ids alb.GetLoadBalancersResult) (*string, error) {
			return &ids.Balancers[0].Id, nil
		}).(pulumi.StringPtrOutput))
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.alicloud.resourcemanager.ResourcemanagerFunctions;
import com.pulumi.alicloud.resourcemanager.inputs.GetResourceGroupsArgs;
import com.pulumi.alicloud.alb.AlbFunctions;
import com.pulumi.alicloud.alb.inputs.GetZonesArgs;
import com.pulumi.alicloud.vpc.Network;
import com.pulumi.alicloud.vpc.NetworkArgs;
import com.pulumi.alicloud.ecs.Eip;
import com.pulumi.alicloud.ecs.EipArgs;
import com.pulumi.alicloud.vpc.Switch;
import com.pulumi.alicloud.vpc.SwitchArgs;
import com.pulumi.alicloud.vpc.Ipv6Gateway;
import com.pulumi.alicloud.vpc.Ipv6GatewayArgs;
import com.pulumi.alicloud.vpc.CommonBandwithPackage;
import com.pulumi.alicloud.vpc.CommonBandwithPackageArgs;
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.inputs.GetLoadBalancersArgs;
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("terraform-example");
        final var default = ResourcemanagerFunctions.getResourceGroups(GetResourceGroupsArgs.builder()
            .build());
        final var defaultGetZones = AlbFunctions.getZones(GetZonesArgs.builder()
            .build());
        var defaultNetwork = new Network("defaultNetwork", NetworkArgs.builder()
            .vpcName(name)
            .cidrBlock("192.168.0.0/16")
            .enableIpv6(true)
            .build());
        var zoneA = new Eip("zoneA", EipArgs.builder()
            .bandwidth("10")
            .internetChargeType("PayByTraffic")
            .build());
        var zoneASwitch = new Switch("zoneASwitch", SwitchArgs.builder()
            .vswitchName(name)
            .vpcId(defaultNetwork.id())
            .cidrBlock("192.168.0.0/18")
            .zoneId(defaultGetZones.zones()[0].id())
            .ipv6CidrBlockMask(6)
            .build());
        var zoneB = new Switch("zoneB", SwitchArgs.builder()
            .vswitchName(name)
            .vpcId(defaultNetwork.id())
            .cidrBlock("192.168.128.0/18")
            .zoneId(defaultGetZones.zones()[1].id())
            .ipv6CidrBlockMask(8)
            .build());
        var defaultIpv6Gateway = new Ipv6Gateway("defaultIpv6Gateway", Ipv6GatewayArgs.builder()
            .ipv6GatewayName(name)
            .vpcId(defaultNetwork.id())
            .build());
        var defaultCommonBandwithPackage = new CommonBandwithPackage("defaultCommonBandwithPackage", CommonBandwithPackageArgs.builder()
            .bandwidth("1000")
            .internetChargeType("PayByBandwidth")
            .build());
        var defaultLoadBalancer = new LoadBalancer("defaultLoadBalancer", LoadBalancerArgs.builder()
            .loadBalancerEdition("Basic")
            .addressType("Internet")
            .vpcId(defaultIpv6Gateway.vpcId())
            .addressAllocatedMode("Fixed")
            .addressIpVersion("DualStack")
            .ipv6AddressType("Internet")
            .bandwidthPackageId(defaultCommonBandwithPackage.id())
            .resourceGroupId(default_.groups()[1].id())
            .loadBalancerName(name)
            .deletionProtectionEnabled(false)
            .loadBalancerBillingConfig(LoadBalancerLoadBalancerBillingConfigArgs.builder()
                .payType("PayAsYouGo")
                .build())
            .zoneMappings(
                LoadBalancerZoneMappingArgs.builder()
                    .vswitchId(zoneASwitch.id())
                    .zoneId(zoneASwitch.zoneId())
                    .eipType("Common")
                    .allocationId(zoneA.id())
                    .intranetAddress("192.168.10.1")
                    .build(),
                LoadBalancerZoneMappingArgs.builder()
                    .vswitchId(zoneB.id())
                    .zoneId(zoneB.zoneId())
                    .build())
            .tags(Map.of("Created", "TF"))
            .build());
        final var ids = AlbFunctions.getLoadBalancers(GetLoadBalancersArgs.builder()
            .ids(defaultLoadBalancer.id())
            .build());
        ctx.export("albLoadBalancersId0", ids.applyValue(_ids -> _ids.balancers()[0].id()));
    }
}
Content copied to clipboard
configuration:
  name:
    type: string
    default: terraform-example
resources:
  defaultNetwork:
    type: alicloud:vpc:Network
    name: default
    properties:
      vpcName: ${name}
      cidrBlock: 192.168.0.0/16
      enableIpv6: 'true'
  zoneA:
    type: alicloud:ecs:Eip
    name: zone_a
    properties:
      bandwidth: '10'
      internetChargeType: PayByTraffic
  zoneASwitch:
    type: alicloud:vpc:Switch
    name: zone_a
    properties:
      vswitchName: ${name}
      vpcId: ${defaultNetwork.id}
      cidrBlock: 192.168.0.0/18
      zoneId: ${defaultGetZones.zones[0].id}
      ipv6CidrBlockMask: '6'
  zoneB:
    type: alicloud:vpc:Switch
    name: zone_b
    properties:
      vswitchName: ${name}
      vpcId: ${defaultNetwork.id}
      cidrBlock: 192.168.128.0/18
      zoneId: ${defaultGetZones.zones[1].id}
      ipv6CidrBlockMask: '8'
  defaultIpv6Gateway:
    type: alicloud:vpc:Ipv6Gateway
    name: default
    properties:
      ipv6GatewayName: ${name}
      vpcId: ${defaultNetwork.id}
  defaultCommonBandwithPackage:
    type: alicloud:vpc:CommonBandwithPackage
    name: default
    properties:
      bandwidth: 1000
      internetChargeType: PayByBandwidth
  defaultLoadBalancer:
    type: alicloud:alb:LoadBalancer
    name: default
    properties:
      loadBalancerEdition: Basic
      addressType: Internet
      vpcId: ${defaultIpv6Gateway.vpcId}
      addressAllocatedMode: Fixed
      addressIpVersion: DualStack
      ipv6AddressType: Internet
      bandwidthPackageId: ${defaultCommonBandwithPackage.id}
      resourceGroupId: ${default.groups[1].id}
      loadBalancerName: ${name}
      deletionProtectionEnabled: false
      loadBalancerBillingConfig:
        payType: PayAsYouGo
      zoneMappings:
        - vswitchId: ${zoneASwitch.id}
          zoneId: ${zoneASwitch.zoneId}
          eipType: Common
          allocationId: ${zoneA.id}
          intranetAddress: 192.168.10.1
        - vswitchId: ${zoneB.id}
          zoneId: ${zoneB.zoneId}
      tags:
        Created: TF
variables:
  default:
    fn::invoke:
      function: alicloud:resourcemanager:getResourceGroups
      arguments: {}
  defaultGetZones:
    fn::invoke:
      function: alicloud:alb:getZones
      arguments: {}
  ids:
    fn::invoke:
      function: alicloud:alb:getLoadBalancers
      arguments:
        ids:
          - ${defaultLoadBalancer.id}
outputs:
  albLoadBalancersId0: ${ids.balancers[0].id}
Content copied to clipboard

Return

A collection of values returned by getLoadBalancers.

Parameters

argument

A collection of arguments for invoking getLoadBalancers.

suspend fun getLoadBalancers(addressType: String? = null, enableDetails: Boolean? = null, ids: List<String>? = null, loadBalancerBusinessStatus: String? = null, loadBalancerBussinessStatus: String? = null, loadBalancerIds: List<String>? = null, loadBalancerName: String? = null, nameRegex: String? = null, outputFile: String? = null, resourceGroupId: String? = null, status: String? = null, tags: Map<String, String>? = null, vpcId: String? = null, vpcIds: List<String>? = null, zoneId: String? = null): GetLoadBalancersResult

Return

A collection of values returned by getLoadBalancers.

Parameters

addressType

The type of IP address that the ALB instance uses to provide services. Valid values: Intranet, Internet.

enableDetails

Whether to query the detailed list of resource attributes. Default value: false.

ids

A list of Load Balancer IDs.

loadBalancerBusinessStatus

Load Balancing of the Service Status. Valid Values: Abnormaland Normal.

loadBalancerBussinessStatus

Field load_balancer_bussiness_status has been deprecated from provider version 1.142.0. New field load_balancer_business_status instead.

loadBalancerIds

The load balancer ids.

loadBalancerName

The name of the resource.

nameRegex

A regex string to filter results by Load Balancer name.

outputFile

File name where to save data source results (after running pulumi preview).

resourceGroupId

The ID of the resource group.

status

The load balancer status. Valid values: Active, Configuring, CreateFailed, Inactive and Provisioning.

tags

A mapping of tags to assign to the resource.

vpcId

The ID of the virtual private cloud (VPC) where the ALB instance is deployed.

vpcIds

The vpc ids.

zoneId

The zone ID of the resource.

See also

.

suspend fun getLoadBalancers(argument: suspend GetLoadBalancersPlainArgsBuilder.() -> Unit): GetLoadBalancersResult

Return

A collection of values returned by getLoadBalancers.

Parameters

argument

Builder for com.pulumi.alicloud.alb.kotlin.inputs.GetLoadBalancersPlainArgs.

See also

.