tencentcloud.getMonitorExternalClusterRegisterCommand

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

const exampleMonitorExternalCluster = new tencentcloud.MonitorExternalCluster("example", {
    instanceId: "prom-gzg3f1em",
    clusterRegion: "ap-guangzhou",
    clusterName: "tf-external-cluster",
    externalLabels: [
        {
            name: "clusterName",
            value: "example",
        },
        {
            name: "environment",
            value: "prod",
        },
    ],
    enableExternal: false,
});
const example = tencentcloud.getMonitorExternalClusterRegisterCommandOutput({
    instanceId: exampleMonitorExternalCluster.instanceId,
    clusterId: exampleMonitorExternalCluster.clusterId,
});

import pulumi
import pulumi_tencentcloud as tencentcloud

example_monitor_external_cluster = tencentcloud.MonitorExternalCluster("example",
    instance_id="prom-gzg3f1em",
    cluster_region="ap-guangzhou",
    cluster_name="tf-external-cluster",
    external_labels=[
        {
            "name": "clusterName",
            "value": "example",
        },
        {
            "name": "environment",
            "value": "prod",
        },
    ],
    enable_external=False)
example = tencentcloud.get_monitor_external_cluster_register_command_output(instance_id=example_monitor_external_cluster.instance_id,
    cluster_id=example_monitor_external_cluster.cluster_id)

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/tencentcloud/tencentcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleMonitorExternalCluster, err := tencentcloud.NewMonitorExternalCluster(ctx, "example", &tencentcloud.MonitorExternalClusterArgs{
			InstanceId:    pulumi.String("prom-gzg3f1em"),
			ClusterRegion: pulumi.String("ap-guangzhou"),
			ClusterName:   pulumi.String("tf-external-cluster"),
			ExternalLabels: tencentcloud.MonitorExternalClusterExternalLabelArray{
				&tencentcloud.MonitorExternalClusterExternalLabelArgs{
					Name:  pulumi.String("clusterName"),
					Value: pulumi.String("example"),
				},
				&tencentcloud.MonitorExternalClusterExternalLabelArgs{
					Name:  pulumi.String("environment"),
					Value: pulumi.String("prod"),
				},
			},
			EnableExternal: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		_ = tencentcloud.GetMonitorExternalClusterRegisterCommandOutput(ctx, tencentcloud.GetMonitorExternalClusterRegisterCommandOutputArgs{
			InstanceId: exampleMonitorExternalCluster.InstanceId,
			ClusterId:  exampleMonitorExternalCluster.ClusterId,
		}, nil)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var exampleMonitorExternalCluster = new Tencentcloud.MonitorExternalCluster("example", new()
    {
        InstanceId = "prom-gzg3f1em",
        ClusterRegion = "ap-guangzhou",
        ClusterName = "tf-external-cluster",
        ExternalLabels = new[]
        {
            new Tencentcloud.Inputs.MonitorExternalClusterExternalLabelArgs
            {
                Name = "clusterName",
                Value = "example",
            },
            new Tencentcloud.Inputs.MonitorExternalClusterExternalLabelArgs
            {
                Name = "environment",
                Value = "prod",
            },
        },
        EnableExternal = false,
    });

    var example = Tencentcloud.GetMonitorExternalClusterRegisterCommand.Invoke(new()
    {
        InstanceId = exampleMonitorExternalCluster.InstanceId,
        ClusterId = exampleMonitorExternalCluster.ClusterId,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.tencentcloud.MonitorExternalCluster;
import com.pulumi.tencentcloud.MonitorExternalClusterArgs;
import com.pulumi.tencentcloud.inputs.MonitorExternalClusterExternalLabelArgs;
import com.pulumi.tencentcloud.TencentcloudFunctions;
import com.pulumi.tencentcloud.inputs.GetMonitorExternalClusterRegisterCommandArgs;
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 exampleMonitorExternalCluster = new MonitorExternalCluster("exampleMonitorExternalCluster", MonitorExternalClusterArgs.builder()
            .instanceId("prom-gzg3f1em")
            .clusterRegion("ap-guangzhou")
            .clusterName("tf-external-cluster")
            .externalLabels(            
                MonitorExternalClusterExternalLabelArgs.builder()
                    .name("clusterName")
                    .value("example")
                    .build(),
                MonitorExternalClusterExternalLabelArgs.builder()
                    .name("environment")
                    .value("prod")
                    .build())
            .enableExternal(false)
            .build());

        final var example = TencentcloudFunctions.getMonitorExternalClusterRegisterCommand(GetMonitorExternalClusterRegisterCommandArgs.builder()
            .instanceId(exampleMonitorExternalCluster.instanceId())
            .clusterId(exampleMonitorExternalCluster.clusterId())
            .build());

    }
}

resources:
  exampleMonitorExternalCluster:
    type: tencentcloud:MonitorExternalCluster
    name: example
    properties:
      instanceId: prom-gzg3f1em
      clusterRegion: ap-guangzhou
      clusterName: tf-external-cluster
      externalLabels:
        - name: clusterName
          value: example
        - name: environment
          value: prod
      enableExternal: false
variables:
  example:
    fn::invoke:
      function: tencentcloud:getMonitorExternalClusterRegisterCommand
      arguments:
        instanceId: ${exampleMonitorExternalCluster.instanceId}
        clusterId: ${exampleMonitorExternalCluster.clusterId}

function getMonitorExternalClusterRegisterCommand(args: GetMonitorExternalClusterRegisterCommandArgs, opts?: InvokeOptions): Promise<GetMonitorExternalClusterRegisterCommandResult>
function getMonitorExternalClusterRegisterCommandOutput(args: GetMonitorExternalClusterRegisterCommandOutputArgs, opts?: InvokeOptions): Output<GetMonitorExternalClusterRegisterCommandResult>

def get_monitor_external_cluster_register_command(cluster_id: Optional[str] = None,
                                                  id: Optional[str] = None,
                                                  instance_id: Optional[str] = None,
                                                  result_output_file: Optional[str] = None,
                                                  opts: Optional[InvokeOptions] = None) -> GetMonitorExternalClusterRegisterCommandResult
def get_monitor_external_cluster_register_command_output(cluster_id: Optional[pulumi.Input[str]] = None,
                                                  id: Optional[pulumi.Input[str]] = None,
                                                  instance_id: Optional[pulumi.Input[str]] = None,
                                                  result_output_file: Optional[pulumi.Input[str]] = None,
                                                  opts: Optional[InvokeOptions] = None) -> Output[GetMonitorExternalClusterRegisterCommandResult]

func GetMonitorExternalClusterRegisterCommand(ctx *Context, args *GetMonitorExternalClusterRegisterCommandArgs, opts ...InvokeOption) (*GetMonitorExternalClusterRegisterCommandResult, error)
func GetMonitorExternalClusterRegisterCommandOutput(ctx *Context, args *GetMonitorExternalClusterRegisterCommandOutputArgs, opts ...InvokeOption) GetMonitorExternalClusterRegisterCommandResultOutput

public static class GetMonitorExternalClusterRegisterCommand 
{
    public static Task<GetMonitorExternalClusterRegisterCommandResult> InvokeAsync(GetMonitorExternalClusterRegisterCommandArgs args, InvokeOptions? opts = null)
    public static Output<GetMonitorExternalClusterRegisterCommandResult> Invoke(GetMonitorExternalClusterRegisterCommandInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetMonitorExternalClusterRegisterCommandResult> getMonitorExternalClusterRegisterCommand(GetMonitorExternalClusterRegisterCommandArgs args, InvokeOptions options)
public static Output<GetMonitorExternalClusterRegisterCommandResult> getMonitorExternalClusterRegisterCommand(GetMonitorExternalClusterRegisterCommandArgs args, InvokeOptions options)

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