alicloud.ga.getEndpointGroups

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

const config = new pulumi.Config();
const region = config.get("region") || "cn-hangzhou";
const name = config.get("name") || "tf-example";
const defaultAccelerators = alicloud.ga.getAccelerators({
    status: "active",
});
const defaultBandwidthPackage = new alicloud.ga.BandwidthPackage("defaultBandwidthPackage", {
    bandwidth: 100,
    type: "Basic",
    bandwidthType: "Basic",
    paymentType: "PayAsYouGo",
    billingType: "PayBy95",
    ratio: 30,
    bandwidthPackageName: name,
    autoPay: true,
    autoUseCoupon: true,
});
const defaultBandwidthPackageAttachment = new alicloud.ga.BandwidthPackageAttachment("defaultBandwidthPackageAttachment", {
    acceleratorId: defaultAccelerators.then(defaultAccelerators => defaultAccelerators.ids?.[0]),
    bandwidthPackageId: defaultBandwidthPackage.id,
});
const defaultListener = new alicloud.ga.Listener("defaultListener", {
    acceleratorId: defaultBandwidthPackageAttachment.acceleratorId,
    clientAffinity: "SOURCE_IP",
    protocol: "UDP",
    portRanges: [{
        fromPort: 60,
        toPort: 70,
    }],
});
const defaultEipAddress = new alicloud.ecs.EipAddress("defaultEipAddress", {
    bandwidth: "10",
    internetChargeType: "PayByBandwidth",
    addressName: name,
});
const defaultEndpointGroup = new alicloud.ga.EndpointGroup("defaultEndpointGroup", {
    acceleratorId: defaultListener.acceleratorId,
    listenerId: defaultListener.id,
    description: name,
    thresholdCount: 4,
    trafficPercentage: 20,
    endpointGroupRegion: "cn-hangzhou",
    healthCheckIntervalSeconds: 3,
    healthCheckPath: "/healthcheck",
    healthCheckPort: 9999,
    healthCheckProtocol: "http",
    portOverrides: {
        endpointPort: 10,
        listenerPort: 60,
    },
    endpointConfigurations: [{
        endpoint: defaultEipAddress.ipAddress,
        type: "PublicIp",
        weight: 20,
    }],
});
const defaultEndpointGroups = alicloud.ga.getEndpointGroupsOutput({
    acceleratorId: defaultEndpointGroup.acceleratorId,
    ids: [defaultEndpointGroup.id],
});
export const firstGaEndpointGroupId = defaultEndpointGroups.apply(defaultEndpointGroups => defaultEndpointGroups.groups?.[0]?.id);

import pulumi
import pulumi_alicloud as alicloud

config = pulumi.Config()
region = config.get("region")
if region is None:
    region = "cn-hangzhou"
name = config.get("name")
if name is None:
    name = "tf-example"
default_accelerators = alicloud.ga.get_accelerators(status="active")
default_bandwidth_package = alicloud.ga.BandwidthPackage("defaultBandwidthPackage",
    bandwidth=100,
    type="Basic",
    bandwidth_type="Basic",
    payment_type="PayAsYouGo",
    billing_type="PayBy95",
    ratio=30,
    bandwidth_package_name=name,
    auto_pay=True,
    auto_use_coupon=True)
default_bandwidth_package_attachment = alicloud.ga.BandwidthPackageAttachment("defaultBandwidthPackageAttachment",
    accelerator_id=default_accelerators.ids[0],
    bandwidth_package_id=default_bandwidth_package.id)
default_listener = alicloud.ga.Listener("defaultListener",
    accelerator_id=default_bandwidth_package_attachment.accelerator_id,
    client_affinity="SOURCE_IP",
    protocol="UDP",
    port_ranges=[alicloud.ga.ListenerPortRangeArgs(
        from_port=60,
        to_port=70,
    )])
default_eip_address = alicloud.ecs.EipAddress("defaultEipAddress",
    bandwidth="10",
    internet_charge_type="PayByBandwidth",
    address_name=name)
default_endpoint_group = alicloud.ga.EndpointGroup("defaultEndpointGroup",
    accelerator_id=default_listener.accelerator_id,
    listener_id=default_listener.id,
    description=name,
    threshold_count=4,
    traffic_percentage=20,
    endpoint_group_region="cn-hangzhou",
    health_check_interval_seconds=3,
    health_check_path="/healthcheck",
    health_check_port=9999,
    health_check_protocol="http",
    port_overrides=alicloud.ga.EndpointGroupPortOverridesArgs(
        endpoint_port=10,
        listener_port=60,
    ),
    endpoint_configurations=[alicloud.ga.EndpointGroupEndpointConfigurationArgs(
        endpoint=default_eip_address.ip_address,
        type="PublicIp",
        weight=20,
    )])
default_endpoint_groups = alicloud.ga.get_endpoint_groups_output(accelerator_id=default_endpoint_group.accelerator_id,
    ids=[default_endpoint_group.id])
pulumi.export("firstGaEndpointGroupId", default_endpoint_groups.groups[0].id)

package main

import (
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/ecs"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/ga"
	"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, "")
		region := "cn-hangzhou"
		if param := cfg.Get("region"); param != "" {
			region = param
		}
		name := "tf-example"
		if param := cfg.Get("name"); param != "" {
			name = param
		}
		defaultAccelerators, err := ga.GetAccelerators(ctx, &ga.GetAcceleratorsArgs{
			Status: pulumi.StringRef("active"),
		}, nil)
		if err != nil {
			return err
		}
		defaultBandwidthPackage, err := ga.NewBandwidthPackage(ctx, "defaultBandwidthPackage", &ga.BandwidthPackageArgs{
			Bandwidth:            pulumi.Int(100),
			Type:                 pulumi.String("Basic"),
			BandwidthType:        pulumi.String("Basic"),
			PaymentType:          pulumi.String("PayAsYouGo"),
			BillingType:          pulumi.String("PayBy95"),
			Ratio:                pulumi.Int(30),
			BandwidthPackageName: pulumi.String(name),
			AutoPay:              pulumi.Bool(true),
			AutoUseCoupon:        pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		defaultBandwidthPackageAttachment, err := ga.NewBandwidthPackageAttachment(ctx, "defaultBandwidthPackageAttachment", &ga.BandwidthPackageAttachmentArgs{
			AcceleratorId:      pulumi.String(defaultAccelerators.Ids[0]),
			BandwidthPackageId: defaultBandwidthPackage.ID(),
		})
		if err != nil {
			return err
		}
		defaultListener, err := ga.NewListener(ctx, "defaultListener", &ga.ListenerArgs{
			AcceleratorId:  defaultBandwidthPackageAttachment.AcceleratorId,
			ClientAffinity: pulumi.String("SOURCE_IP"),
			Protocol:       pulumi.String("UDP"),
			PortRanges: ga.ListenerPortRangeArray{
				&ga.ListenerPortRangeArgs{
					FromPort: pulumi.Int(60),
					ToPort:   pulumi.Int(70),
				},
			},
		})
		if err != nil {
			return err
		}
		defaultEipAddress, err := ecs.NewEipAddress(ctx, "defaultEipAddress", &ecs.EipAddressArgs{
			Bandwidth:          pulumi.String("10"),
			InternetChargeType: pulumi.String("PayByBandwidth"),
			AddressName:        pulumi.String(name),
		})
		if err != nil {
			return err
		}
		defaultEndpointGroup, err := ga.NewEndpointGroup(ctx, "defaultEndpointGroup", &ga.EndpointGroupArgs{
			AcceleratorId:              defaultListener.AcceleratorId,
			ListenerId:                 defaultListener.ID(),
			Description:                pulumi.String(name),
			ThresholdCount:             pulumi.Int(4),
			TrafficPercentage:          pulumi.Int(20),
			EndpointGroupRegion:        pulumi.String("cn-hangzhou"),
			HealthCheckIntervalSeconds: pulumi.Int(3),
			HealthCheckPath:            pulumi.String("/healthcheck"),
			HealthCheckPort:            pulumi.Int(9999),
			HealthCheckProtocol:        pulumi.String("http"),
			PortOverrides: &ga.EndpointGroupPortOverridesArgs{
				EndpointPort: pulumi.Int(10),
				ListenerPort: pulumi.Int(60),
			},
			EndpointConfigurations: ga.EndpointGroupEndpointConfigurationArray{
				&ga.EndpointGroupEndpointConfigurationArgs{
					Endpoint: defaultEipAddress.IpAddress,
					Type:     pulumi.String("PublicIp"),
					Weight:   pulumi.Int(20),
				},
			},
		})
		if err != nil {
			return err
		}
		defaultEndpointGroups := ga.GetEndpointGroupsOutput(ctx, ga.GetEndpointGroupsOutputArgs{
			AcceleratorId: defaultEndpointGroup.AcceleratorId,
			Ids: pulumi.StringArray{
				defaultEndpointGroup.ID(),
			},
		}, nil)
		ctx.Export("firstGaEndpointGroupId", defaultEndpointGroups.ApplyT(func(defaultEndpointGroups ga.GetEndpointGroupsResult) (*string, error) {
			return &defaultEndpointGroups.Groups[0].Id, nil
		}).(pulumi.StringPtrOutput))
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var region = config.Get("region") ?? "cn-hangzhou";
    var name = config.Get("name") ?? "tf-example";
    var defaultAccelerators = AliCloud.Ga.GetAccelerators.Invoke(new()
    {
        Status = "active",
    });

    var defaultBandwidthPackage = new AliCloud.Ga.BandwidthPackage("defaultBandwidthPackage", new()
    {
        Bandwidth = 100,
        Type = "Basic",
        BandwidthType = "Basic",
        PaymentType = "PayAsYouGo",
        BillingType = "PayBy95",
        Ratio = 30,
        BandwidthPackageName = name,
        AutoPay = true,
        AutoUseCoupon = true,
    });

    var defaultBandwidthPackageAttachment = new AliCloud.Ga.BandwidthPackageAttachment("defaultBandwidthPackageAttachment", new()
    {
        AcceleratorId = defaultAccelerators.Apply(getAcceleratorsResult => getAcceleratorsResult.Ids[0]),
        BandwidthPackageId = defaultBandwidthPackage.Id,
    });

    var defaultListener = new AliCloud.Ga.Listener("defaultListener", new()
    {
        AcceleratorId = defaultBandwidthPackageAttachment.AcceleratorId,
        ClientAffinity = "SOURCE_IP",
        Protocol = "UDP",
        PortRanges = new[]
        {
            new AliCloud.Ga.Inputs.ListenerPortRangeArgs
            {
                FromPort = 60,
                ToPort = 70,
            },
        },
    });

    var defaultEipAddress = new AliCloud.Ecs.EipAddress("defaultEipAddress", new()
    {
        Bandwidth = "10",
        InternetChargeType = "PayByBandwidth",
        AddressName = name,
    });

    var defaultEndpointGroup = new AliCloud.Ga.EndpointGroup("defaultEndpointGroup", new()
    {
        AcceleratorId = defaultListener.AcceleratorId,
        ListenerId = defaultListener.Id,
        Description = name,
        ThresholdCount = 4,
        TrafficPercentage = 20,
        EndpointGroupRegion = "cn-hangzhou",
        HealthCheckIntervalSeconds = 3,
        HealthCheckPath = "/healthcheck",
        HealthCheckPort = 9999,
        HealthCheckProtocol = "http",
        PortOverrides = new AliCloud.Ga.Inputs.EndpointGroupPortOverridesArgs
        {
            EndpointPort = 10,
            ListenerPort = 60,
        },
        EndpointConfigurations = new[]
        {
            new AliCloud.Ga.Inputs.EndpointGroupEndpointConfigurationArgs
            {
                Endpoint = defaultEipAddress.IpAddress,
                Type = "PublicIp",
                Weight = 20,
            },
        },
    });

    var defaultEndpointGroups = AliCloud.Ga.GetEndpointGroups.Invoke(new()
    {
        AcceleratorId = defaultEndpointGroup.AcceleratorId,
        Ids = new[]
        {
            defaultEndpointGroup.Id,
        },
    });

    return new Dictionary<string, object?>
    {
        ["firstGaEndpointGroupId"] = defaultEndpointGroups.Apply(getEndpointGroupsResult => getEndpointGroupsResult.Groups[0]?.Id),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.alicloud.ga.GaFunctions;
import com.pulumi.alicloud.ga.inputs.GetAcceleratorsArgs;
import com.pulumi.alicloud.ga.BandwidthPackage;
import com.pulumi.alicloud.ga.BandwidthPackageArgs;
import com.pulumi.alicloud.ga.BandwidthPackageAttachment;
import com.pulumi.alicloud.ga.BandwidthPackageAttachmentArgs;
import com.pulumi.alicloud.ga.Listener;
import com.pulumi.alicloud.ga.ListenerArgs;
import com.pulumi.alicloud.ga.inputs.ListenerPortRangeArgs;
import com.pulumi.alicloud.ecs.EipAddress;
import com.pulumi.alicloud.ecs.EipAddressArgs;
import com.pulumi.alicloud.ga.EndpointGroup;
import com.pulumi.alicloud.ga.EndpointGroupArgs;
import com.pulumi.alicloud.ga.inputs.EndpointGroupPortOverridesArgs;
import com.pulumi.alicloud.ga.inputs.EndpointGroupEndpointConfigurationArgs;
import com.pulumi.alicloud.ga.inputs.GetEndpointGroupsArgs;
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 region = config.get("region").orElse("cn-hangzhou");
        final var name = config.get("name").orElse("tf-example");
        final var defaultAccelerators = GaFunctions.getAccelerators(GetAcceleratorsArgs.builder()
            .status("active")
            .build());

        var defaultBandwidthPackage = new BandwidthPackage("defaultBandwidthPackage", BandwidthPackageArgs.builder()        
            .bandwidth(100)
            .type("Basic")
            .bandwidthType("Basic")
            .paymentType("PayAsYouGo")
            .billingType("PayBy95")
            .ratio(30)
            .bandwidthPackageName(name)
            .autoPay(true)
            .autoUseCoupon(true)
            .build());

        var defaultBandwidthPackageAttachment = new BandwidthPackageAttachment("defaultBandwidthPackageAttachment", BandwidthPackageAttachmentArgs.builder()        
            .acceleratorId(defaultAccelerators.applyValue(getAcceleratorsResult -> getAcceleratorsResult.ids()[0]))
            .bandwidthPackageId(defaultBandwidthPackage.id())
            .build());

        var defaultListener = new Listener("defaultListener", ListenerArgs.builder()        
            .acceleratorId(defaultBandwidthPackageAttachment.acceleratorId())
            .clientAffinity("SOURCE_IP")
            .protocol("UDP")
            .portRanges(ListenerPortRangeArgs.builder()
                .fromPort("60")
                .toPort("70")
                .build())
            .build());

        var defaultEipAddress = new EipAddress("defaultEipAddress", EipAddressArgs.builder()        
            .bandwidth("10")
            .internetChargeType("PayByBandwidth")
            .addressName(name)
            .build());

        var defaultEndpointGroup = new EndpointGroup("defaultEndpointGroup", EndpointGroupArgs.builder()        
            .acceleratorId(defaultListener.acceleratorId())
            .listenerId(defaultListener.id())
            .description(name)
            .thresholdCount(4)
            .trafficPercentage(20)
            .endpointGroupRegion("cn-hangzhou")
            .healthCheckIntervalSeconds("3")
            .healthCheckPath("/healthcheck")
            .healthCheckPort("9999")
            .healthCheckProtocol("http")
            .portOverrides(EndpointGroupPortOverridesArgs.builder()
                .endpointPort("10")
                .listenerPort("60")
                .build())
            .endpointConfigurations(EndpointGroupEndpointConfigurationArgs.builder()
                .endpoint(defaultEipAddress.ipAddress())
                .type("PublicIp")
                .weight("20")
                .build())
            .build());

        final var defaultEndpointGroups = GaFunctions.getEndpointGroups(GetEndpointGroupsArgs.builder()
            .acceleratorId(defaultEndpointGroup.acceleratorId())
            .ids(defaultEndpointGroup.id())
            .build());

        ctx.export("firstGaEndpointGroupId", defaultEndpointGroups.applyValue(getEndpointGroupsResult -> getEndpointGroupsResult).applyValue(defaultEndpointGroups -> defaultEndpointGroups.applyValue(getEndpointGroupsResult -> getEndpointGroupsResult.groups()[0].id())));
    }
}

configuration:
  region:
    type: string
    default: cn-hangzhou
  name:
    type: string
    default: tf-example
resources:
  defaultBandwidthPackage:
    type: alicloud:ga:BandwidthPackage
    properties:
      bandwidth: 100
      type: Basic
      bandwidthType: Basic
      paymentType: PayAsYouGo
      billingType: PayBy95
      ratio: 30
      bandwidthPackageName: ${name}
      autoPay: true
      autoUseCoupon: true
  defaultBandwidthPackageAttachment:
    type: alicloud:ga:BandwidthPackageAttachment
    properties:
      acceleratorId: ${defaultAccelerators.ids[0]}
      bandwidthPackageId: ${defaultBandwidthPackage.id}
  defaultListener:
    type: alicloud:ga:Listener
    properties:
      acceleratorId: ${defaultBandwidthPackageAttachment.acceleratorId}
      clientAffinity: SOURCE_IP
      protocol: UDP
      portRanges:
        - fromPort: '60'
          toPort: '70'
  defaultEipAddress:
    type: alicloud:ecs:EipAddress
    properties:
      bandwidth: '10'
      internetChargeType: PayByBandwidth
      addressName: ${name}
  defaultEndpointGroup:
    type: alicloud:ga:EndpointGroup
    properties:
      acceleratorId: ${defaultListener.acceleratorId}
      listenerId: ${defaultListener.id}
      description: ${name}
      thresholdCount: 4
      trafficPercentage: 20
      endpointGroupRegion: cn-hangzhou
      healthCheckIntervalSeconds: '3'
      healthCheckPath: /healthcheck
      healthCheckPort: '9999'
      healthCheckProtocol: http
      portOverrides:
        endpointPort: '10'
        listenerPort: '60'
      endpointConfigurations:
        - endpoint: ${defaultEipAddress.ipAddress}
          type: PublicIp
          weight: '20'
variables:
  defaultAccelerators:
    fn::invoke:
      Function: alicloud:ga:getAccelerators
      Arguments:
        status: active
  defaultEndpointGroups:
    fn::invoke:
      Function: alicloud:ga:getEndpointGroups
      Arguments:
        acceleratorId: ${defaultEndpointGroup.acceleratorId}
        ids:
          - ${defaultEndpointGroup.id}
outputs:
  firstGaEndpointGroupId: ${defaultEndpointGroups.groups[0].id}

function getEndpointGroups(args: GetEndpointGroupsArgs, opts?: InvokeOptions): Promise<GetEndpointGroupsResult>
function getEndpointGroupsOutput(args: GetEndpointGroupsOutputArgs, opts?: InvokeOptions): Output<GetEndpointGroupsResult>

def get_endpoint_groups(accelerator_id: Optional[str] = None,
                        endpoint_group_type: Optional[str] = None,
                        ids: Optional[Sequence[str]] = None,
                        listener_id: Optional[str] = None,
                        name_regex: Optional[str] = None,
                        output_file: Optional[str] = None,
                        status: Optional[str] = None,
                        opts: Optional[InvokeOptions] = None) -> GetEndpointGroupsResult
def get_endpoint_groups_output(accelerator_id: Optional[pulumi.Input[str]] = None,
                        endpoint_group_type: Optional[pulumi.Input[str]] = None,
                        ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                        listener_id: Optional[pulumi.Input[str]] = None,
                        name_regex: Optional[pulumi.Input[str]] = None,
                        output_file: Optional[pulumi.Input[str]] = None,
                        status: Optional[pulumi.Input[str]] = None,
                        opts: Optional[InvokeOptions] = None) -> Output[GetEndpointGroupsResult]

func GetEndpointGroups(ctx *Context, args *GetEndpointGroupsArgs, opts ...InvokeOption) (*GetEndpointGroupsResult, error)
func GetEndpointGroupsOutput(ctx *Context, args *GetEndpointGroupsOutputArgs, opts ...InvokeOption) GetEndpointGroupsResultOutput

public static class GetEndpointGroups 
{
    public static Task<GetEndpointGroupsResult> InvokeAsync(GetEndpointGroupsArgs args, InvokeOptions? opts = null)
    public static Output<GetEndpointGroupsResult> Invoke(GetEndpointGroupsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetEndpointGroupsResult> getEndpointGroups(GetEndpointGroupsArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: alicloud:ga/getEndpointGroups:getEndpointGroups
  arguments:
    # arguments dictionary