tencentcloud.getTdmqRocketmqTopic

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

const exampleTdmqRocketmqCluster = new tencentcloud.TdmqRocketmqCluster("example", {
    clusterName: "tf_example",
    remark: "remark.",
});
const exampleTdmqRocketmqNamespace = new tencentcloud.TdmqRocketmqNamespace("example", {
    clusterId: exampleTdmqRocketmqCluster.clusterId,
    namespaceName: "tf_example",
    remark: "remark.",
});
const exampleTdmqRocketmqTopic = new tencentcloud.TdmqRocketmqTopic("example", {
    topicName: "tf_example",
    namespaceName: exampleTdmqRocketmqNamespace.namespaceName,
    clusterId: exampleTdmqRocketmqCluster.clusterId,
    type: "Normal",
    remark: "remark.",
});
const example = tencentcloud.getTdmqRocketmqTopicOutput({
    clusterId: exampleTdmqRocketmqCluster.clusterId,
    namespaceId: exampleTdmqRocketmqNamespace.namespaceName,
    filterName: exampleTdmqRocketmqTopic.topicName,
});

import pulumi
import pulumi_tencentcloud as tencentcloud

example_tdmq_rocketmq_cluster = tencentcloud.TdmqRocketmqCluster("example",
    cluster_name="tf_example",
    remark="remark.")
example_tdmq_rocketmq_namespace = tencentcloud.TdmqRocketmqNamespace("example",
    cluster_id=example_tdmq_rocketmq_cluster.cluster_id,
    namespace_name="tf_example",
    remark="remark.")
example_tdmq_rocketmq_topic = tencentcloud.TdmqRocketmqTopic("example",
    topic_name="tf_example",
    namespace_name=example_tdmq_rocketmq_namespace.namespace_name,
    cluster_id=example_tdmq_rocketmq_cluster.cluster_id,
    type="Normal",
    remark="remark.")
example = tencentcloud.get_tdmq_rocketmq_topic_output(cluster_id=example_tdmq_rocketmq_cluster.cluster_id,
    namespace_id=example_tdmq_rocketmq_namespace.namespace_name,
    filter_name=example_tdmq_rocketmq_topic.topic_name)

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 {
		exampleTdmqRocketmqCluster, err := tencentcloud.NewTdmqRocketmqCluster(ctx, "example", &tencentcloud.TdmqRocketmqClusterArgs{
			ClusterName: pulumi.String("tf_example"),
			Remark:      pulumi.String("remark."),
		})
		if err != nil {
			return err
		}
		exampleTdmqRocketmqNamespace, err := tencentcloud.NewTdmqRocketmqNamespace(ctx, "example", &tencentcloud.TdmqRocketmqNamespaceArgs{
			ClusterId:     exampleTdmqRocketmqCluster.ClusterId,
			NamespaceName: pulumi.String("tf_example"),
			Remark:        pulumi.String("remark."),
		})
		if err != nil {
			return err
		}
		exampleTdmqRocketmqTopic, err := tencentcloud.NewTdmqRocketmqTopic(ctx, "example", &tencentcloud.TdmqRocketmqTopicArgs{
			TopicName:     pulumi.String("tf_example"),
			NamespaceName: exampleTdmqRocketmqNamespace.NamespaceName,
			ClusterId:     exampleTdmqRocketmqCluster.ClusterId,
			Type:          pulumi.String("Normal"),
			Remark:        pulumi.String("remark."),
		})
		if err != nil {
			return err
		}
		_ = tencentcloud.LookupTdmqRocketmqTopicOutput(ctx, tencentcloud.GetTdmqRocketmqTopicOutputArgs{
			ClusterId:   exampleTdmqRocketmqCluster.ClusterId,
			NamespaceId: exampleTdmqRocketmqNamespace.NamespaceName,
			FilterName:  exampleTdmqRocketmqTopic.TopicName,
		}, nil)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var exampleTdmqRocketmqCluster = new Tencentcloud.TdmqRocketmqCluster("example", new()
    {
        ClusterName = "tf_example",
        Remark = "remark.",
    });

    var exampleTdmqRocketmqNamespace = new Tencentcloud.TdmqRocketmqNamespace("example", new()
    {
        ClusterId = exampleTdmqRocketmqCluster.ClusterId,
        NamespaceName = "tf_example",
        Remark = "remark.",
    });

    var exampleTdmqRocketmqTopic = new Tencentcloud.TdmqRocketmqTopic("example", new()
    {
        TopicName = "tf_example",
        NamespaceName = exampleTdmqRocketmqNamespace.NamespaceName,
        ClusterId = exampleTdmqRocketmqCluster.ClusterId,
        Type = "Normal",
        Remark = "remark.",
    });

    var example = Tencentcloud.GetTdmqRocketmqTopic.Invoke(new()
    {
        ClusterId = exampleTdmqRocketmqCluster.ClusterId,
        NamespaceId = exampleTdmqRocketmqNamespace.NamespaceName,
        FilterName = exampleTdmqRocketmqTopic.TopicName,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.tencentcloud.TdmqRocketmqCluster;
import com.pulumi.tencentcloud.TdmqRocketmqClusterArgs;
import com.pulumi.tencentcloud.TdmqRocketmqNamespace;
import com.pulumi.tencentcloud.TdmqRocketmqNamespaceArgs;
import com.pulumi.tencentcloud.TdmqRocketmqTopic;
import com.pulumi.tencentcloud.TdmqRocketmqTopicArgs;
import com.pulumi.tencentcloud.TencentcloudFunctions;
import com.pulumi.tencentcloud.inputs.GetTdmqRocketmqTopicArgs;
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 exampleTdmqRocketmqCluster = new TdmqRocketmqCluster("exampleTdmqRocketmqCluster", TdmqRocketmqClusterArgs.builder()
            .clusterName("tf_example")
            .remark("remark.")
            .build());

        var exampleTdmqRocketmqNamespace = new TdmqRocketmqNamespace("exampleTdmqRocketmqNamespace", TdmqRocketmqNamespaceArgs.builder()
            .clusterId(exampleTdmqRocketmqCluster.clusterId())
            .namespaceName("tf_example")
            .remark("remark.")
            .build());

        var exampleTdmqRocketmqTopic = new TdmqRocketmqTopic("exampleTdmqRocketmqTopic", TdmqRocketmqTopicArgs.builder()
            .topicName("tf_example")
            .namespaceName(exampleTdmqRocketmqNamespace.namespaceName())
            .clusterId(exampleTdmqRocketmqCluster.clusterId())
            .type("Normal")
            .remark("remark.")
            .build());

        final var example = TencentcloudFunctions.getTdmqRocketmqTopic(GetTdmqRocketmqTopicArgs.builder()
            .clusterId(exampleTdmqRocketmqCluster.clusterId())
            .namespaceId(exampleTdmqRocketmqNamespace.namespaceName())
            .filterName(exampleTdmqRocketmqTopic.topicName())
            .build());

    }
}

resources:
  exampleTdmqRocketmqCluster:
    type: tencentcloud:TdmqRocketmqCluster
    name: example
    properties:
      clusterName: tf_example
      remark: remark.
  exampleTdmqRocketmqNamespace:
    type: tencentcloud:TdmqRocketmqNamespace
    name: example
    properties:
      clusterId: ${exampleTdmqRocketmqCluster.clusterId}
      namespaceName: tf_example
      remark: remark.
  exampleTdmqRocketmqTopic:
    type: tencentcloud:TdmqRocketmqTopic
    name: example
    properties:
      topicName: tf_example
      namespaceName: ${exampleTdmqRocketmqNamespace.namespaceName}
      clusterId: ${exampleTdmqRocketmqCluster.clusterId}
      type: Normal
      remark: remark.
variables:
  example:
    fn::invoke:
      function: tencentcloud:getTdmqRocketmqTopic
      arguments:
        clusterId: ${exampleTdmqRocketmqCluster.clusterId}
        namespaceId: ${exampleTdmqRocketmqNamespace.namespaceName}
        filterName: ${exampleTdmqRocketmqTopic.topicName}

function getTdmqRocketmqTopic(args: GetTdmqRocketmqTopicArgs, opts?: InvokeOptions): Promise<GetTdmqRocketmqTopicResult>
function getTdmqRocketmqTopicOutput(args: GetTdmqRocketmqTopicOutputArgs, opts?: InvokeOptions): Output<GetTdmqRocketmqTopicResult>

def get_tdmq_rocketmq_topic(cluster_id: Optional[str] = None,
                            filter_name: Optional[str] = None,
                            filter_types: Optional[Sequence[str]] = None,
                            id: Optional[str] = None,
                            namespace_id: Optional[str] = None,
                            result_output_file: Optional[str] = None,
                            opts: Optional[InvokeOptions] = None) -> GetTdmqRocketmqTopicResult
def get_tdmq_rocketmq_topic_output(cluster_id: Optional[pulumi.Input[str]] = None,
                            filter_name: Optional[pulumi.Input[str]] = None,
                            filter_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                            id: Optional[pulumi.Input[str]] = None,
                            namespace_id: Optional[pulumi.Input[str]] = None,
                            result_output_file: Optional[pulumi.Input[str]] = None,
                            opts: Optional[InvokeOptions] = None) -> Output[GetTdmqRocketmqTopicResult]

func LookupTdmqRocketmqTopic(ctx *Context, args *LookupTdmqRocketmqTopicArgs, opts ...InvokeOption) (*LookupTdmqRocketmqTopicResult, error)
func LookupTdmqRocketmqTopicOutput(ctx *Context, args *LookupTdmqRocketmqTopicOutputArgs, opts ...InvokeOption) LookupTdmqRocketmqTopicResultOutput

public static class GetTdmqRocketmqTopic 
{
    public static Task<GetTdmqRocketmqTopicResult> InvokeAsync(GetTdmqRocketmqTopicArgs args, InvokeOptions? opts = null)
    public static Output<GetTdmqRocketmqTopicResult> Invoke(GetTdmqRocketmqTopicInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetTdmqRocketmqTopicResult> getTdmqRocketmqTopic(GetTdmqRocketmqTopicArgs args, InvokeOptions options)
public static Output<GetTdmqRocketmqTopicResult> getTdmqRocketmqTopic(GetTdmqRocketmqTopicArgs args, InvokeOptions options)

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