tencentcloud.getCcnBandwidthLimits

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

const config = new pulumi.Config();
const otherRegion1 = config.get("otherRegion1") || "ap-shanghai";
const main = new tencentcloud.Ccn("main", {
    name: "ci-temp-test-ccn",
    description: "ci-temp-test-ccn-des",
    qos: "AG",
});
const limit = tencentcloud.getCcnBandwidthLimitsOutput({
    ccnId: main.ccnId,
});
const limit1 = new tencentcloud.CcnBandwidthLimit("limit1", {
    ccnId: main.ccnId,
    region: otherRegion1,
    bandwidthLimit: 500,
});

import pulumi
import pulumi_tencentcloud as tencentcloud

config = pulumi.Config()
other_region1 = config.get("otherRegion1")
if other_region1 is None:
    other_region1 = "ap-shanghai"
main = tencentcloud.Ccn("main",
    name="ci-temp-test-ccn",
    description="ci-temp-test-ccn-des",
    qos="AG")
limit = tencentcloud.get_ccn_bandwidth_limits_output(ccn_id=main.ccn_id)
limit1 = tencentcloud.CcnBandwidthLimit("limit1",
    ccn_id=main.ccn_id,
    region=other_region1,
    bandwidth_limit=500)

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/tencentcloud/tencentcloud"
	"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, "")
		otherRegion1 := "ap-shanghai"
		if param := cfg.Get("otherRegion1"); param != "" {
			otherRegion1 = param
		}
		main, err := tencentcloud.NewCcn(ctx, "main", &tencentcloud.CcnArgs{
			Name:        pulumi.String("ci-temp-test-ccn"),
			Description: pulumi.String("ci-temp-test-ccn-des"),
			Qos:         pulumi.String("AG"),
		})
		if err != nil {
			return err
		}
		_ = tencentcloud.GetCcnBandwidthLimitsOutput(ctx, tencentcloud.GetCcnBandwidthLimitsOutputArgs{
			CcnId: main.CcnId,
		}, nil)
		_, err = tencentcloud.NewCcnBandwidthLimit(ctx, "limit1", &tencentcloud.CcnBandwidthLimitArgs{
			CcnId:          main.CcnId,
			Region:         pulumi.String(otherRegion1),
			BandwidthLimit: pulumi.Float64(500),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var otherRegion1 = config.Get("otherRegion1") ?? "ap-shanghai";
    var main = new Tencentcloud.Ccn("main", new()
    {
        Name = "ci-temp-test-ccn",
        Description = "ci-temp-test-ccn-des",
        Qos = "AG",
    });

    var limit = Tencentcloud.GetCcnBandwidthLimits.Invoke(new()
    {
        CcnId = main.CcnId,
    });

    var limit1 = new Tencentcloud.CcnBandwidthLimit("limit1", new()
    {
        CcnId = main.CcnId,
        Region = otherRegion1,
        BandwidthLimit = 500,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.tencentcloud.Ccn;
import com.pulumi.tencentcloud.CcnArgs;
import com.pulumi.tencentcloud.TencentcloudFunctions;
import com.pulumi.tencentcloud.inputs.GetCcnBandwidthLimitsArgs;
import com.pulumi.tencentcloud.CcnBandwidthLimit;
import com.pulumi.tencentcloud.CcnBandwidthLimitArgs;
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 otherRegion1 = config.get("otherRegion1").orElse("ap-shanghai");
        var main = new Ccn("main", CcnArgs.builder()
            .name("ci-temp-test-ccn")
            .description("ci-temp-test-ccn-des")
            .qos("AG")
            .build());

        final var limit = TencentcloudFunctions.getCcnBandwidthLimits(GetCcnBandwidthLimitsArgs.builder()
            .ccnId(main.ccnId())
            .build());

        var limit1 = new CcnBandwidthLimit("limit1", CcnBandwidthLimitArgs.builder()
            .ccnId(main.ccnId())
            .region(otherRegion1)
            .bandwidthLimit(500.0)
            .build());

    }
}

configuration:
  otherRegion1:
    type: string
    default: ap-shanghai
resources:
  main:
    type: tencentcloud:Ccn
    properties:
      name: ci-temp-test-ccn
      description: ci-temp-test-ccn-des
      qos: AG
  limit1:
    type: tencentcloud:CcnBandwidthLimit
    properties:
      ccnId: ${main.ccnId}
      region: ${otherRegion1}
      bandwidthLimit: 500
variables:
  limit:
    fn::invoke:
      function: tencentcloud:getCcnBandwidthLimits
      arguments:
        ccnId: ${main.ccnId}

function getCcnBandwidthLimits(args: GetCcnBandwidthLimitsArgs, opts?: InvokeOptions): Promise<GetCcnBandwidthLimitsResult>
function getCcnBandwidthLimitsOutput(args: GetCcnBandwidthLimitsOutputArgs, opts?: InvokeOptions): Output<GetCcnBandwidthLimitsResult>

def get_ccn_bandwidth_limits(ccn_id: Optional[str] = None,
                             id: Optional[str] = None,
                             result_output_file: Optional[str] = None,
                             opts: Optional[InvokeOptions] = None) -> GetCcnBandwidthLimitsResult
def get_ccn_bandwidth_limits_output(ccn_id: Optional[pulumi.Input[str]] = None,
                             id: Optional[pulumi.Input[str]] = None,
                             result_output_file: Optional[pulumi.Input[str]] = None,
                             opts: Optional[InvokeOptions] = None) -> Output[GetCcnBandwidthLimitsResult]

func GetCcnBandwidthLimits(ctx *Context, args *GetCcnBandwidthLimitsArgs, opts ...InvokeOption) (*GetCcnBandwidthLimitsResult, error)
func GetCcnBandwidthLimitsOutput(ctx *Context, args *GetCcnBandwidthLimitsOutputArgs, opts ...InvokeOption) GetCcnBandwidthLimitsResultOutput

public static class GetCcnBandwidthLimits 
{
    public static Task<GetCcnBandwidthLimitsResult> InvokeAsync(GetCcnBandwidthLimitsArgs args, InvokeOptions? opts = null)
    public static Output<GetCcnBandwidthLimitsResult> Invoke(GetCcnBandwidthLimitsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetCcnBandwidthLimitsResult> getCcnBandwidthLimits(GetCcnBandwidthLimitsArgs args, InvokeOptions options)
public static Output<GetCcnBandwidthLimitsResult> getCcnBandwidthLimits(GetCcnBandwidthLimitsArgs args, InvokeOptions options)

fn::invoke:
  function: tencentcloud:index/getCcnBandwidthLimits:getCcnBandwidthLimits
  arguments:
    # arguments dictionary