tencentcloud.getSqlserverPublishSubscribes

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

const zones = tencentcloud.getAvailabilityZonesByProduct({
    product: "sqlserver",
});
const vpc = new tencentcloud.Vpc("vpc", {cidrBlock: "10.0.0.0/16"});
const subnet = new tencentcloud.Subnet("subnet", {
    availabilityZone: zones.then(zones => zones.zones?.[4]?.name),
    vpcId: vpc.vpcId,
    cidrBlock: "10.0.0.0/16",
    isMulticast: false,
});
const securityGroup = new tencentcloud.SecurityGroup("securityGroup", {description: "desc."});
const examplePubSqlserverGeneralCloudInstance = new tencentcloud.SqlserverGeneralCloudInstance("examplePubSqlserverGeneralCloudInstance", {
    zone: zones.then(zones => zones.zones?.[4]?.name),
    memory: 4,
    storage: 100,
    cpu: 2,
    machineType: "CLOUD_HSSD",
    instanceChargeType: "POSTPAID",
    projectId: 0,
    subnetId: subnet.subnetId,
    vpcId: vpc.vpcId,
    dbVersion: "2008R2",
    securityGroupLists: [securityGroup.securityGroupId],
    weeklies: [
        1,
        2,
        3,
        5,
        6,
        7,
    ],
    startTime: "00:00",
    span: 6,
    resourceTags: [{
        tagKey: "test",
        tagValue: "test",
    }],
    collation: "Chinese_PRC_CI_AS",
    timeZone: "China Standard Time",
});
const exampleSubSqlserverGeneralCloudInstance = new tencentcloud.SqlserverGeneralCloudInstance("exampleSubSqlserverGeneralCloudInstance", {
    zone: zones.then(zones => zones.zones?.[4]?.name),
    memory: 4,
    storage: 100,
    cpu: 2,
    machineType: "CLOUD_HSSD",
    instanceChargeType: "POSTPAID",
    projectId: 0,
    subnetId: subnet.subnetId,
    vpcId: vpc.vpcId,
    dbVersion: "2008R2",
    securityGroupLists: [securityGroup.securityGroupId],
    weeklies: [
        1,
        2,
        3,
        5,
        6,
        7,
    ],
    startTime: "00:00",
    span: 6,
    resourceTags: [{
        tagKey: "test",
        tagValue: "test",
    }],
    collation: "Chinese_PRC_CI_AS",
    timeZone: "China Standard Time",
});
const examplePubSqlserverDb = new tencentcloud.SqlserverDb("examplePubSqlserverDb", {
    instanceId: examplePubSqlserverGeneralCloudInstance.sqlserverGeneralCloudInstanceId,
    charset: "Chinese_PRC_BIN",
    remark: "test-remark",
});
const exampleSubSqlserverDb = new tencentcloud.SqlserverDb("exampleSubSqlserverDb", {
    instanceId: exampleSubSqlserverGeneralCloudInstance.sqlserverGeneralCloudInstanceId,
    charset: "Chinese_PRC_BIN",
    remark: "test-remark",
});
const exampleSqlserverPublishSubscribe = new tencentcloud.SqlserverPublishSubscribe("exampleSqlserverPublishSubscribe", {
    publishInstanceId: examplePubSqlserverGeneralCloudInstance.sqlserverGeneralCloudInstanceId,
    subscribeInstanceId: exampleSubSqlserverGeneralCloudInstance.sqlserverGeneralCloudInstanceId,
    publishSubscribeName: "example",
    deleteSubscribeDb: false,
    databaseTuples: [{
        publishDatabase: examplePubSqlserverDb.name,
        subscribeDatabase: exampleSubSqlserverDb.name,
    }],
});
const exampleSqlserverPublishSubscribes = tencentcloud.getSqlserverPublishSubscribesOutput({
    instanceId: exampleSqlserverPublishSubscribe.publishInstanceId,
});

import pulumi
import pulumi_tencentcloud as tencentcloud

zones = tencentcloud.get_availability_zones_by_product(product="sqlserver")
vpc = tencentcloud.Vpc("vpc", cidr_block="10.0.0.0/16")
subnet = tencentcloud.Subnet("subnet",
    availability_zone=zones.zones[4].name,
    vpc_id=vpc.vpc_id,
    cidr_block="10.0.0.0/16",
    is_multicast=False)
security_group = tencentcloud.SecurityGroup("securityGroup", description="desc.")
example_pub_sqlserver_general_cloud_instance = tencentcloud.SqlserverGeneralCloudInstance("examplePubSqlserverGeneralCloudInstance",
    zone=zones.zones[4].name,
    memory=4,
    storage=100,
    cpu=2,
    machine_type="CLOUD_HSSD",
    instance_charge_type="POSTPAID",
    project_id=0,
    subnet_id=subnet.subnet_id,
    vpc_id=vpc.vpc_id,
    db_version="2008R2",
    security_group_lists=[security_group.security_group_id],
    weeklies=[
        1,
        2,
        3,
        5,
        6,
        7,
    ],
    start_time="00:00",
    span=6,
    resource_tags=[{
        "tag_key": "test",
        "tag_value": "test",
    }],
    collation="Chinese_PRC_CI_AS",
    time_zone="China Standard Time")
example_sub_sqlserver_general_cloud_instance = tencentcloud.SqlserverGeneralCloudInstance("exampleSubSqlserverGeneralCloudInstance",
    zone=zones.zones[4].name,
    memory=4,
    storage=100,
    cpu=2,
    machine_type="CLOUD_HSSD",
    instance_charge_type="POSTPAID",
    project_id=0,
    subnet_id=subnet.subnet_id,
    vpc_id=vpc.vpc_id,
    db_version="2008R2",
    security_group_lists=[security_group.security_group_id],
    weeklies=[
        1,
        2,
        3,
        5,
        6,
        7,
    ],
    start_time="00:00",
    span=6,
    resource_tags=[{
        "tag_key": "test",
        "tag_value": "test",
    }],
    collation="Chinese_PRC_CI_AS",
    time_zone="China Standard Time")
example_pub_sqlserver_db = tencentcloud.SqlserverDb("examplePubSqlserverDb",
    instance_id=example_pub_sqlserver_general_cloud_instance.sqlserver_general_cloud_instance_id,
    charset="Chinese_PRC_BIN",
    remark="test-remark")
example_sub_sqlserver_db = tencentcloud.SqlserverDb("exampleSubSqlserverDb",
    instance_id=example_sub_sqlserver_general_cloud_instance.sqlserver_general_cloud_instance_id,
    charset="Chinese_PRC_BIN",
    remark="test-remark")
example_sqlserver_publish_subscribe = tencentcloud.SqlserverPublishSubscribe("exampleSqlserverPublishSubscribe",
    publish_instance_id=example_pub_sqlserver_general_cloud_instance.sqlserver_general_cloud_instance_id,
    subscribe_instance_id=example_sub_sqlserver_general_cloud_instance.sqlserver_general_cloud_instance_id,
    publish_subscribe_name="example",
    delete_subscribe_db=False,
    database_tuples=[{
        "publish_database": example_pub_sqlserver_db.name,
        "subscribe_database": example_sub_sqlserver_db.name,
    }])
example_sqlserver_publish_subscribes = tencentcloud.get_sqlserver_publish_subscribes_output(instance_id=example_sqlserver_publish_subscribe.publish_instance_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 {
		zones, err := tencentcloud.GetAvailabilityZonesByProduct(ctx, &tencentcloud.GetAvailabilityZonesByProductArgs{
			Product: "sqlserver",
		}, nil)
		if err != nil {
			return err
		}
		vpc, err := tencentcloud.NewVpc(ctx, "vpc", &tencentcloud.VpcArgs{
			CidrBlock: pulumi.String("10.0.0.0/16"),
		})
		if err != nil {
			return err
		}
		subnet, err := tencentcloud.NewSubnet(ctx, "subnet", &tencentcloud.SubnetArgs{
			AvailabilityZone: pulumi.String(zones.Zones[4].Name),
			VpcId:            vpc.VpcId,
			CidrBlock:        pulumi.String("10.0.0.0/16"),
			IsMulticast:      pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		securityGroup, err := tencentcloud.NewSecurityGroup(ctx, "securityGroup", &tencentcloud.SecurityGroupArgs{
			Description: pulumi.String("desc."),
		})
		if err != nil {
			return err
		}
		examplePubSqlserverGeneralCloudInstance, err := tencentcloud.NewSqlserverGeneralCloudInstance(ctx, "examplePubSqlserverGeneralCloudInstance", &tencentcloud.SqlserverGeneralCloudInstanceArgs{
			Zone:               pulumi.String(zones.Zones[4].Name),
			Memory:             pulumi.Float64(4),
			Storage:            pulumi.Float64(100),
			Cpu:                pulumi.Float64(2),
			MachineType:        pulumi.String("CLOUD_HSSD"),
			InstanceChargeType: pulumi.String("POSTPAID"),
			ProjectId:          pulumi.Float64(0),
			SubnetId:           subnet.SubnetId,
			VpcId:              vpc.VpcId,
			DbVersion:          pulumi.String("2008R2"),
			SecurityGroupLists: pulumi.StringArray{
				securityGroup.SecurityGroupId,
			},
			Weeklies: pulumi.Float64Array{
				pulumi.Float64(1),
				pulumi.Float64(2),
				pulumi.Float64(3),
				pulumi.Float64(5),
				pulumi.Float64(6),
				pulumi.Float64(7),
			},
			StartTime: pulumi.String("00:00"),
			Span:      pulumi.Float64(6),
			ResourceTags: tencentcloud.SqlserverGeneralCloudInstanceResourceTagArray{
				&tencentcloud.SqlserverGeneralCloudInstanceResourceTagArgs{
					TagKey:   pulumi.String("test"),
					TagValue: pulumi.String("test"),
				},
			},
			Collation: pulumi.String("Chinese_PRC_CI_AS"),
			TimeZone:  pulumi.String("China Standard Time"),
		})
		if err != nil {
			return err
		}
		exampleSubSqlserverGeneralCloudInstance, err := tencentcloud.NewSqlserverGeneralCloudInstance(ctx, "exampleSubSqlserverGeneralCloudInstance", &tencentcloud.SqlserverGeneralCloudInstanceArgs{
			Zone:               pulumi.String(zones.Zones[4].Name),
			Memory:             pulumi.Float64(4),
			Storage:            pulumi.Float64(100),
			Cpu:                pulumi.Float64(2),
			MachineType:        pulumi.String("CLOUD_HSSD"),
			InstanceChargeType: pulumi.String("POSTPAID"),
			ProjectId:          pulumi.Float64(0),
			SubnetId:           subnet.SubnetId,
			VpcId:              vpc.VpcId,
			DbVersion:          pulumi.String("2008R2"),
			SecurityGroupLists: pulumi.StringArray{
				securityGroup.SecurityGroupId,
			},
			Weeklies: pulumi.Float64Array{
				pulumi.Float64(1),
				pulumi.Float64(2),
				pulumi.Float64(3),
				pulumi.Float64(5),
				pulumi.Float64(6),
				pulumi.Float64(7),
			},
			StartTime: pulumi.String("00:00"),
			Span:      pulumi.Float64(6),
			ResourceTags: tencentcloud.SqlserverGeneralCloudInstanceResourceTagArray{
				&tencentcloud.SqlserverGeneralCloudInstanceResourceTagArgs{
					TagKey:   pulumi.String("test"),
					TagValue: pulumi.String("test"),
				},
			},
			Collation: pulumi.String("Chinese_PRC_CI_AS"),
			TimeZone:  pulumi.String("China Standard Time"),
		})
		if err != nil {
			return err
		}
		examplePubSqlserverDb, err := tencentcloud.NewSqlserverDb(ctx, "examplePubSqlserverDb", &tencentcloud.SqlserverDbArgs{
			InstanceId: examplePubSqlserverGeneralCloudInstance.SqlserverGeneralCloudInstanceId,
			Charset:    pulumi.String("Chinese_PRC_BIN"),
			Remark:     pulumi.String("test-remark"),
		})
		if err != nil {
			return err
		}
		exampleSubSqlserverDb, err := tencentcloud.NewSqlserverDb(ctx, "exampleSubSqlserverDb", &tencentcloud.SqlserverDbArgs{
			InstanceId: exampleSubSqlserverGeneralCloudInstance.SqlserverGeneralCloudInstanceId,
			Charset:    pulumi.String("Chinese_PRC_BIN"),
			Remark:     pulumi.String("test-remark"),
		})
		if err != nil {
			return err
		}
		exampleSqlserverPublishSubscribe, err := tencentcloud.NewSqlserverPublishSubscribe(ctx, "exampleSqlserverPublishSubscribe", &tencentcloud.SqlserverPublishSubscribeArgs{
			PublishInstanceId:    examplePubSqlserverGeneralCloudInstance.SqlserverGeneralCloudInstanceId,
			SubscribeInstanceId:  exampleSubSqlserverGeneralCloudInstance.SqlserverGeneralCloudInstanceId,
			PublishSubscribeName: pulumi.String("example"),
			DeleteSubscribeDb:    pulumi.Bool(false),
			DatabaseTuples: tencentcloud.SqlserverPublishSubscribeDatabaseTupleArray{
				&tencentcloud.SqlserverPublishSubscribeDatabaseTupleArgs{
					PublishDatabase:   examplePubSqlserverDb.Name,
					SubscribeDatabase: exampleSubSqlserverDb.Name,
				},
			},
		})
		if err != nil {
			return err
		}
		_ = tencentcloud.GetSqlserverPublishSubscribesOutput(ctx, tencentcloud.GetSqlserverPublishSubscribesOutputArgs{
			InstanceId: exampleSqlserverPublishSubscribe.PublishInstanceId,
		}, nil)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var zones = Tencentcloud.GetAvailabilityZonesByProduct.Invoke(new()
    {
        Product = "sqlserver",
    });

    var vpc = new Tencentcloud.Vpc("vpc", new()
    {
        CidrBlock = "10.0.0.0/16",
    });

    var subnet = new Tencentcloud.Subnet("subnet", new()
    {
        AvailabilityZone = zones.Apply(getAvailabilityZonesByProductResult => getAvailabilityZonesByProductResult.Zones[4]?.Name),
        VpcId = vpc.VpcId,
        CidrBlock = "10.0.0.0/16",
        IsMulticast = false,
    });

    var securityGroup = new Tencentcloud.SecurityGroup("securityGroup", new()
    {
        Description = "desc.",
    });

    var examplePubSqlserverGeneralCloudInstance = new Tencentcloud.SqlserverGeneralCloudInstance("examplePubSqlserverGeneralCloudInstance", new()
    {
        Zone = zones.Apply(getAvailabilityZonesByProductResult => getAvailabilityZonesByProductResult.Zones[4]?.Name),
        Memory = 4,
        Storage = 100,
        Cpu = 2,
        MachineType = "CLOUD_HSSD",
        InstanceChargeType = "POSTPAID",
        ProjectId = 0,
        SubnetId = subnet.SubnetId,
        VpcId = vpc.VpcId,
        DbVersion = "2008R2",
        SecurityGroupLists = new[]
        {
            securityGroup.SecurityGroupId,
        },
        Weeklies = new[]
        {
            1,
            2,
            3,
            5,
            6,
            7,
        },
        StartTime = "00:00",
        Span = 6,
        ResourceTags = new[]
        {
            new Tencentcloud.Inputs.SqlserverGeneralCloudInstanceResourceTagArgs
            {
                TagKey = "test",
                TagValue = "test",
            },
        },
        Collation = "Chinese_PRC_CI_AS",
        TimeZone = "China Standard Time",
    });

    var exampleSubSqlserverGeneralCloudInstance = new Tencentcloud.SqlserverGeneralCloudInstance("exampleSubSqlserverGeneralCloudInstance", new()
    {
        Zone = zones.Apply(getAvailabilityZonesByProductResult => getAvailabilityZonesByProductResult.Zones[4]?.Name),
        Memory = 4,
        Storage = 100,
        Cpu = 2,
        MachineType = "CLOUD_HSSD",
        InstanceChargeType = "POSTPAID",
        ProjectId = 0,
        SubnetId = subnet.SubnetId,
        VpcId = vpc.VpcId,
        DbVersion = "2008R2",
        SecurityGroupLists = new[]
        {
            securityGroup.SecurityGroupId,
        },
        Weeklies = new[]
        {
            1,
            2,
            3,
            5,
            6,
            7,
        },
        StartTime = "00:00",
        Span = 6,
        ResourceTags = new[]
        {
            new Tencentcloud.Inputs.SqlserverGeneralCloudInstanceResourceTagArgs
            {
                TagKey = "test",
                TagValue = "test",
            },
        },
        Collation = "Chinese_PRC_CI_AS",
        TimeZone = "China Standard Time",
    });

    var examplePubSqlserverDb = new Tencentcloud.SqlserverDb("examplePubSqlserverDb", new()
    {
        InstanceId = examplePubSqlserverGeneralCloudInstance.SqlserverGeneralCloudInstanceId,
        Charset = "Chinese_PRC_BIN",
        Remark = "test-remark",
    });

    var exampleSubSqlserverDb = new Tencentcloud.SqlserverDb("exampleSubSqlserverDb", new()
    {
        InstanceId = exampleSubSqlserverGeneralCloudInstance.SqlserverGeneralCloudInstanceId,
        Charset = "Chinese_PRC_BIN",
        Remark = "test-remark",
    });

    var exampleSqlserverPublishSubscribe = new Tencentcloud.SqlserverPublishSubscribe("exampleSqlserverPublishSubscribe", new()
    {
        PublishInstanceId = examplePubSqlserverGeneralCloudInstance.SqlserverGeneralCloudInstanceId,
        SubscribeInstanceId = exampleSubSqlserverGeneralCloudInstance.SqlserverGeneralCloudInstanceId,
        PublishSubscribeName = "example",
        DeleteSubscribeDb = false,
        DatabaseTuples = new[]
        {
            new Tencentcloud.Inputs.SqlserverPublishSubscribeDatabaseTupleArgs
            {
                PublishDatabase = examplePubSqlserverDb.Name,
                SubscribeDatabase = exampleSubSqlserverDb.Name,
            },
        },
    });

    var exampleSqlserverPublishSubscribes = Tencentcloud.GetSqlserverPublishSubscribes.Invoke(new()
    {
        InstanceId = exampleSqlserverPublishSubscribe.PublishInstanceId,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.tencentcloud.TencentcloudFunctions;
import com.pulumi.tencentcloud.inputs.GetAvailabilityZonesByProductArgs;
import com.pulumi.tencentcloud.Vpc;
import com.pulumi.tencentcloud.VpcArgs;
import com.pulumi.tencentcloud.Subnet;
import com.pulumi.tencentcloud.SubnetArgs;
import com.pulumi.tencentcloud.SecurityGroup;
import com.pulumi.tencentcloud.SecurityGroupArgs;
import com.pulumi.tencentcloud.SqlserverGeneralCloudInstance;
import com.pulumi.tencentcloud.SqlserverGeneralCloudInstanceArgs;
import com.pulumi.tencentcloud.inputs.SqlserverGeneralCloudInstanceResourceTagArgs;
import com.pulumi.tencentcloud.SqlserverDb;
import com.pulumi.tencentcloud.SqlserverDbArgs;
import com.pulumi.tencentcloud.SqlserverPublishSubscribe;
import com.pulumi.tencentcloud.SqlserverPublishSubscribeArgs;
import com.pulumi.tencentcloud.inputs.SqlserverPublishSubscribeDatabaseTupleArgs;
import com.pulumi.tencentcloud.inputs.GetSqlserverPublishSubscribesArgs;
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 zones = TencentcloudFunctions.getAvailabilityZonesByProduct(GetAvailabilityZonesByProductArgs.builder()
            .product("sqlserver")
            .build());

        var vpc = new Vpc("vpc", VpcArgs.builder()
            .cidrBlock("10.0.0.0/16")
            .build());

        var subnet = new Subnet("subnet", SubnetArgs.builder()
            .availabilityZone(zones.applyValue(getAvailabilityZonesByProductResult -> getAvailabilityZonesByProductResult.zones()[4].name()))
            .vpcId(vpc.vpcId())
            .cidrBlock("10.0.0.0/16")
            .isMulticast(false)
            .build());

        var securityGroup = new SecurityGroup("securityGroup", SecurityGroupArgs.builder()
            .description("desc.")
            .build());

        var examplePubSqlserverGeneralCloudInstance = new SqlserverGeneralCloudInstance("examplePubSqlserverGeneralCloudInstance", SqlserverGeneralCloudInstanceArgs.builder()
            .zone(zones.applyValue(getAvailabilityZonesByProductResult -> getAvailabilityZonesByProductResult.zones()[4].name()))
            .memory(4)
            .storage(100)
            .cpu(2)
            .machineType("CLOUD_HSSD")
            .instanceChargeType("POSTPAID")
            .projectId(0)
            .subnetId(subnet.subnetId())
            .vpcId(vpc.vpcId())
            .dbVersion("2008R2")
            .securityGroupLists(securityGroup.securityGroupId())
            .weeklies(            
                1,
                2,
                3,
                5,
                6,
                7)
            .startTime("00:00")
            .span(6)
            .resourceTags(SqlserverGeneralCloudInstanceResourceTagArgs.builder()
                .tagKey("test")
                .tagValue("test")
                .build())
            .collation("Chinese_PRC_CI_AS")
            .timeZone("China Standard Time")
            .build());

        var exampleSubSqlserverGeneralCloudInstance = new SqlserverGeneralCloudInstance("exampleSubSqlserverGeneralCloudInstance", SqlserverGeneralCloudInstanceArgs.builder()
            .zone(zones.applyValue(getAvailabilityZonesByProductResult -> getAvailabilityZonesByProductResult.zones()[4].name()))
            .memory(4)
            .storage(100)
            .cpu(2)
            .machineType("CLOUD_HSSD")
            .instanceChargeType("POSTPAID")
            .projectId(0)
            .subnetId(subnet.subnetId())
            .vpcId(vpc.vpcId())
            .dbVersion("2008R2")
            .securityGroupLists(securityGroup.securityGroupId())
            .weeklies(            
                1,
                2,
                3,
                5,
                6,
                7)
            .startTime("00:00")
            .span(6)
            .resourceTags(SqlserverGeneralCloudInstanceResourceTagArgs.builder()
                .tagKey("test")
                .tagValue("test")
                .build())
            .collation("Chinese_PRC_CI_AS")
            .timeZone("China Standard Time")
            .build());

        var examplePubSqlserverDb = new SqlserverDb("examplePubSqlserverDb", SqlserverDbArgs.builder()
            .instanceId(examplePubSqlserverGeneralCloudInstance.sqlserverGeneralCloudInstanceId())
            .charset("Chinese_PRC_BIN")
            .remark("test-remark")
            .build());

        var exampleSubSqlserverDb = new SqlserverDb("exampleSubSqlserverDb", SqlserverDbArgs.builder()
            .instanceId(exampleSubSqlserverGeneralCloudInstance.sqlserverGeneralCloudInstanceId())
            .charset("Chinese_PRC_BIN")
            .remark("test-remark")
            .build());

        var exampleSqlserverPublishSubscribe = new SqlserverPublishSubscribe("exampleSqlserverPublishSubscribe", SqlserverPublishSubscribeArgs.builder()
            .publishInstanceId(examplePubSqlserverGeneralCloudInstance.sqlserverGeneralCloudInstanceId())
            .subscribeInstanceId(exampleSubSqlserverGeneralCloudInstance.sqlserverGeneralCloudInstanceId())
            .publishSubscribeName("example")
            .deleteSubscribeDb(false)
            .databaseTuples(SqlserverPublishSubscribeDatabaseTupleArgs.builder()
                .publishDatabase(examplePubSqlserverDb.name())
                .subscribeDatabase(exampleSubSqlserverDb.name())
                .build())
            .build());

        final var exampleSqlserverPublishSubscribes = TencentcloudFunctions.getSqlserverPublishSubscribes(GetSqlserverPublishSubscribesArgs.builder()
            .instanceId(exampleSqlserverPublishSubscribe.publishInstanceId())
            .build());

    }
}

resources:
  vpc:
    type: tencentcloud:Vpc
    properties:
      cidrBlock: 10.0.0.0/16
  subnet:
    type: tencentcloud:Subnet
    properties:
      availabilityZone: ${zones.zones[4].name}
      vpcId: ${vpc.vpcId}
      cidrBlock: 10.0.0.0/16
      isMulticast: false
  securityGroup:
    type: tencentcloud:SecurityGroup
    properties:
      description: desc.
  examplePubSqlserverGeneralCloudInstance:
    type: tencentcloud:SqlserverGeneralCloudInstance
    properties:
      zone: ${zones.zones[4].name}
      memory: 4
      storage: 100
      cpu: 2
      machineType: CLOUD_HSSD
      instanceChargeType: POSTPAID
      projectId: 0
      subnetId: ${subnet.subnetId}
      vpcId: ${vpc.vpcId}
      dbVersion: 2008R2
      securityGroupLists:
        - ${securityGroup.securityGroupId}
      weeklies:
        - 1
        - 2
        - 3
        - 5
        - 6
        - 7
      startTime: 00:00
      span: 6
      resourceTags:
        - tagKey: test
          tagValue: test
      collation: Chinese_PRC_CI_AS
      timeZone: China Standard Time
  exampleSubSqlserverGeneralCloudInstance:
    type: tencentcloud:SqlserverGeneralCloudInstance
    properties:
      zone: ${zones.zones[4].name}
      memory: 4
      storage: 100
      cpu: 2
      machineType: CLOUD_HSSD
      instanceChargeType: POSTPAID
      projectId: 0
      subnetId: ${subnet.subnetId}
      vpcId: ${vpc.vpcId}
      dbVersion: 2008R2
      securityGroupLists:
        - ${securityGroup.securityGroupId}
      weeklies:
        - 1
        - 2
        - 3
        - 5
        - 6
        - 7
      startTime: 00:00
      span: 6
      resourceTags:
        - tagKey: test
          tagValue: test
      collation: Chinese_PRC_CI_AS
      timeZone: China Standard Time
  examplePubSqlserverDb:
    type: tencentcloud:SqlserverDb
    properties:
      instanceId: ${examplePubSqlserverGeneralCloudInstance.sqlserverGeneralCloudInstanceId}
      charset: Chinese_PRC_BIN
      remark: test-remark
  exampleSubSqlserverDb:
    type: tencentcloud:SqlserverDb
    properties:
      instanceId: ${exampleSubSqlserverGeneralCloudInstance.sqlserverGeneralCloudInstanceId}
      charset: Chinese_PRC_BIN
      remark: test-remark
  exampleSqlserverPublishSubscribe:
    type: tencentcloud:SqlserverPublishSubscribe
    properties:
      publishInstanceId: ${examplePubSqlserverGeneralCloudInstance.sqlserverGeneralCloudInstanceId}
      subscribeInstanceId: ${exampleSubSqlserverGeneralCloudInstance.sqlserverGeneralCloudInstanceId}
      publishSubscribeName: example
      deleteSubscribeDb: false
      databaseTuples:
        - publishDatabase: ${examplePubSqlserverDb.name}
          subscribeDatabase: ${exampleSubSqlserverDb.name}
variables:
  exampleSqlserverPublishSubscribes:
    fn::invoke:
      function: tencentcloud:getSqlserverPublishSubscribes
      arguments:
        instanceId: ${exampleSqlserverPublishSubscribe.publishInstanceId}
  zones:
    fn::invoke:
      function: tencentcloud:getAvailabilityZonesByProduct
      arguments:
        product: sqlserver

function getSqlserverPublishSubscribes(args: GetSqlserverPublishSubscribesArgs, opts?: InvokeOptions): Promise<GetSqlserverPublishSubscribesResult>
function getSqlserverPublishSubscribesOutput(args: GetSqlserverPublishSubscribesOutputArgs, opts?: InvokeOptions): Output<GetSqlserverPublishSubscribesResult>

def get_sqlserver_publish_subscribes(id: Optional[str] = None,
                                     instance_id: Optional[str] = None,
                                     pub_or_sub_instance_id: Optional[str] = None,
                                     pub_or_sub_instance_ip: Optional[str] = None,
                                     publish_database: Optional[str] = None,
                                     publish_subscribe_id: Optional[float] = None,
                                     publish_subscribe_name: Optional[str] = None,
                                     result_output_file: Optional[str] = None,
                                     subscribe_database: Optional[str] = None,
                                     opts: Optional[InvokeOptions] = None) -> GetSqlserverPublishSubscribesResult
def get_sqlserver_publish_subscribes_output(id: Optional[pulumi.Input[str]] = None,
                                     instance_id: Optional[pulumi.Input[str]] = None,
                                     pub_or_sub_instance_id: Optional[pulumi.Input[str]] = None,
                                     pub_or_sub_instance_ip: Optional[pulumi.Input[str]] = None,
                                     publish_database: Optional[pulumi.Input[str]] = None,
                                     publish_subscribe_id: Optional[pulumi.Input[float]] = None,
                                     publish_subscribe_name: Optional[pulumi.Input[str]] = None,
                                     result_output_file: Optional[pulumi.Input[str]] = None,
                                     subscribe_database: Optional[pulumi.Input[str]] = None,
                                     opts: Optional[InvokeOptions] = None) -> Output[GetSqlserverPublishSubscribesResult]

func GetSqlserverPublishSubscribes(ctx *Context, args *GetSqlserverPublishSubscribesArgs, opts ...InvokeOption) (*GetSqlserverPublishSubscribesResult, error)
func GetSqlserverPublishSubscribesOutput(ctx *Context, args *GetSqlserverPublishSubscribesOutputArgs, opts ...InvokeOption) GetSqlserverPublishSubscribesResultOutput

public static class GetSqlserverPublishSubscribes 
{
    public static Task<GetSqlserverPublishSubscribesResult> InvokeAsync(GetSqlserverPublishSubscribesArgs args, InvokeOptions? opts = null)
    public static Output<GetSqlserverPublishSubscribesResult> Invoke(GetSqlserverPublishSubscribesInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetSqlserverPublishSubscribesResult> getSqlserverPublishSubscribes(GetSqlserverPublishSubscribesArgs args, InvokeOptions options)
public static Output<GetSqlserverPublishSubscribesResult> getSqlserverPublishSubscribes(GetSqlserverPublishSubscribesArgs args, InvokeOptions options)

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