tencentcloud.MonitorTmpTkeGlobalNotification

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

const config = new pulumi.Config();
const defaultInstanceType = config.get("defaultInstanceType") || "SA1.MEDIUM2";
const availabilityZoneFirst = config.get("availabilityZoneFirst") || "ap-guangzhou-3";
const availabilityZoneSecond = config.get("availabilityZoneSecond") || "ap-guangzhou-4";
const exampleClusterCidr = config.get("exampleClusterCidr") || "10.31.0.0/16";
const vpcOne = tencentcloud.getVpcSubnets({
    isDefault: true,
    availabilityZone: availabilityZoneFirst,
});
const firstVpcId = vpcOne.then(vpcOne => vpcOne.instanceLists?.[0]?.vpcId);
const firstSubnetId = vpcOne.then(vpcOne => vpcOne.instanceLists?.[0]?.subnetId);
const vpcTwo = tencentcloud.getVpcSubnets({
    isDefault: true,
    availabilityZone: availabilityZoneSecond,
});
const secondVpcId = vpcTwo.then(vpcTwo => vpcTwo.instanceLists?.[0]?.vpcId);
const secondSubnetId = vpcTwo.then(vpcTwo => vpcTwo.instanceLists?.[0]?.subnetId);
const sg = new tencentcloud.SecurityGroup("sg", {});
const sgId = sg.securityGroupId;
const _default = tencentcloud.getImages({
    imageTypes: ["PUBLIC_IMAGE"],
    imageNameRegex: "Final",
});
const imageId = _default.then(_default => _default.imageId);
const sgRule = new tencentcloud.SecurityGroupLiteRule("sgRule", {
    securityGroupId: sg.securityGroupId,
    ingresses: [
        "ACCEPT#10.0.0.0/16#ALL#ALL",
        "ACCEPT#172.16.0.0/22#ALL#ALL",
        "DROP#0.0.0.0/0#ALL#ALL",
    ],
    egresses: ["ACCEPT#172.16.0.0/22#ALL#ALL"],
});
const example = new tencentcloud.KubernetesCluster("example", {
    vpcId: firstVpcId,
    clusterCidr: exampleClusterCidr,
    clusterMaxPodNum: 32,
    clusterName: "tf_example_cluster",
    clusterDesc: "example for tke cluster",
    clusterMaxServiceNum: 32,
    clusterInternet: false,
    clusterInternetSecurityGroup: sgId,
    clusterVersion: "1.22.5",
    clusterDeployType: "MANAGED_CLUSTER",
    workerConfigs: [
        {
            count: 1,
            availabilityZone: availabilityZoneFirst,
            instanceType: defaultInstanceType,
            systemDiskType: "CLOUD_SSD",
            systemDiskSize: 60,
            internetChargeType: "TRAFFIC_POSTPAID_BY_HOUR",
            internetMaxBandwidthOut: 100,
            publicIpAssigned: true,
            subnetId: firstSubnetId,
            imgId: imageId,
            dataDisks: [{
                diskType: "CLOUD_PREMIUM",
                diskSize: 50,
            }],
            enhancedSecurityService: false,
            enhancedMonitorService: false,
            userData: "dGVzdA==",
            password: "ZZXXccvv1212",
        },
        {
            count: 1,
            availabilityZone: availabilityZoneSecond,
            instanceType: defaultInstanceType,
            systemDiskType: "CLOUD_SSD",
            systemDiskSize: 60,
            internetChargeType: "TRAFFIC_POSTPAID_BY_HOUR",
            internetMaxBandwidthOut: 100,
            publicIpAssigned: true,
            subnetId: secondSubnetId,
            dataDisks: [{
                diskType: "CLOUD_PREMIUM",
                diskSize: 50,
            }],
            enhancedSecurityService: false,
            enhancedMonitorService: false,
            userData: "dGVzdA==",
            camRoleName: "CVM_QcsRole",
            password: "ZZXXccvv1212",
        },
    ],
    labels: {
        test1: "test1",
        test2: "test2",
    },
});
const zone = config.get("zone") || "ap-guangzhou";
const clusterType = config.get("clusterType") || "tke";
const fooMonitorTmpInstance = new tencentcloud.MonitorTmpInstance("fooMonitorTmpInstance", {
    instanceName: "tf-tmp-instance",
    vpcId: firstVpcId,
    subnetId: firstSubnetId,
    dataRetentionTime: 30,
    zone: availabilityZoneSecond,
    tags: {
        createdBy: "terraform",
    },
});
// tmp tke bind
const fooMonitorTmpTkeClusterAgent = new tencentcloud.MonitorTmpTkeClusterAgent("fooMonitorTmpTkeClusterAgent", {
    instanceId: fooMonitorTmpInstance.monitorTmpInstanceId,
    agents: {
        region: zone,
        clusterType: clusterType,
        clusterId: example.kubernetesClusterId,
        enableExternal: false,
    },
});
// create record rule
const basic = new tencentcloud.MonitorTmpTkeGlobalNotification("basic", {
    instanceId: fooMonitorTmpInstance.monitorTmpInstanceId,
    notification: {
        enabled: true,
        type: "webhook",
        alertManagers: [{
            clusterId: "",
            clusterType: "",
            url: "",
        }],
        webHook: "",
        repeatInterval: "5m",
        timeRangeStart: "00:00:00",
        timeRangeEnd: "23:59:59",
        notifyWays: [
            "SMS",
            "EMAIL",
        ],
        receiverGroups: [],
        phoneNotifyOrders: [],
        phoneCircleTimes: 0,
        phoneInnerInterval: 0,
        phoneCircleInterval: 0,
        phoneArriveNotice: false,
    },
}, {
    dependsOn: [fooMonitorTmpTkeClusterAgent],
});

import pulumi
import pulumi_tencentcloud as tencentcloud

config = pulumi.Config()
default_instance_type = config.get("defaultInstanceType")
if default_instance_type is None:
    default_instance_type = "SA1.MEDIUM2"
availability_zone_first = config.get("availabilityZoneFirst")
if availability_zone_first is None:
    availability_zone_first = "ap-guangzhou-3"
availability_zone_second = config.get("availabilityZoneSecond")
if availability_zone_second is None:
    availability_zone_second = "ap-guangzhou-4"
example_cluster_cidr = config.get("exampleClusterCidr")
if example_cluster_cidr is None:
    example_cluster_cidr = "10.31.0.0/16"
vpc_one = tencentcloud.get_vpc_subnets(is_default=True,
    availability_zone=availability_zone_first)
first_vpc_id = vpc_one.instance_lists[0].vpc_id
first_subnet_id = vpc_one.instance_lists[0].subnet_id
vpc_two = tencentcloud.get_vpc_subnets(is_default=True,
    availability_zone=availability_zone_second)
second_vpc_id = vpc_two.instance_lists[0].vpc_id
second_subnet_id = vpc_two.instance_lists[0].subnet_id
sg = tencentcloud.SecurityGroup("sg")
sg_id = sg.security_group_id
default = tencentcloud.get_images(image_types=["PUBLIC_IMAGE"],
    image_name_regex="Final")
image_id = default.image_id
sg_rule = tencentcloud.SecurityGroupLiteRule("sgRule",
    security_group_id=sg.security_group_id,
    ingresses=[
        "ACCEPT#10.0.0.0/16#ALL#ALL",
        "ACCEPT#172.16.0.0/22#ALL#ALL",
        "DROP#0.0.0.0/0#ALL#ALL",
    ],
    egresses=["ACCEPT#172.16.0.0/22#ALL#ALL"])
example = tencentcloud.KubernetesCluster("example",
    vpc_id=first_vpc_id,
    cluster_cidr=example_cluster_cidr,
    cluster_max_pod_num=32,
    cluster_name="tf_example_cluster",
    cluster_desc="example for tke cluster",
    cluster_max_service_num=32,
    cluster_internet=False,
    cluster_internet_security_group=sg_id,
    cluster_version="1.22.5",
    cluster_deploy_type="MANAGED_CLUSTER",
    worker_configs=[
        {
            "count": 1,
            "availability_zone": availability_zone_first,
            "instance_type": default_instance_type,
            "system_disk_type": "CLOUD_SSD",
            "system_disk_size": 60,
            "internet_charge_type": "TRAFFIC_POSTPAID_BY_HOUR",
            "internet_max_bandwidth_out": 100,
            "public_ip_assigned": True,
            "subnet_id": first_subnet_id,
            "img_id": image_id,
            "data_disks": [{
                "disk_type": "CLOUD_PREMIUM",
                "disk_size": 50,
            }],
            "enhanced_security_service": False,
            "enhanced_monitor_service": False,
            "user_data": "dGVzdA==",
            "password": "ZZXXccvv1212",
        },
        {
            "count": 1,
            "availability_zone": availability_zone_second,
            "instance_type": default_instance_type,
            "system_disk_type": "CLOUD_SSD",
            "system_disk_size": 60,
            "internet_charge_type": "TRAFFIC_POSTPAID_BY_HOUR",
            "internet_max_bandwidth_out": 100,
            "public_ip_assigned": True,
            "subnet_id": second_subnet_id,
            "data_disks": [{
                "disk_type": "CLOUD_PREMIUM",
                "disk_size": 50,
            }],
            "enhanced_security_service": False,
            "enhanced_monitor_service": False,
            "user_data": "dGVzdA==",
            "cam_role_name": "CVM_QcsRole",
            "password": "ZZXXccvv1212",
        },
    ],
    labels={
        "test1": "test1",
        "test2": "test2",
    })
zone = config.get("zone")
if zone is None:
    zone = "ap-guangzhou"
cluster_type = config.get("clusterType")
if cluster_type is None:
    cluster_type = "tke"
foo_monitor_tmp_instance = tencentcloud.MonitorTmpInstance("fooMonitorTmpInstance",
    instance_name="tf-tmp-instance",
    vpc_id=first_vpc_id,
    subnet_id=first_subnet_id,
    data_retention_time=30,
    zone=availability_zone_second,
    tags={
        "createdBy": "terraform",
    })
# tmp tke bind
foo_monitor_tmp_tke_cluster_agent = tencentcloud.MonitorTmpTkeClusterAgent("fooMonitorTmpTkeClusterAgent",
    instance_id=foo_monitor_tmp_instance.monitor_tmp_instance_id,
    agents={
        "region": zone,
        "cluster_type": cluster_type,
        "cluster_id": example.kubernetes_cluster_id,
        "enable_external": False,
    })
# create record rule
basic = tencentcloud.MonitorTmpTkeGlobalNotification("basic",
    instance_id=foo_monitor_tmp_instance.monitor_tmp_instance_id,
    notification={
        "enabled": True,
        "type": "webhook",
        "alert_managers": [{
            "cluster_id": "",
            "cluster_type": "",
            "url": "",
        }],
        "web_hook": "",
        "repeat_interval": "5m",
        "time_range_start": "00:00:00",
        "time_range_end": "23:59:59",
        "notify_ways": [
            "SMS",
            "EMAIL",
        ],
        "receiver_groups": [],
        "phone_notify_orders": [],
        "phone_circle_times": 0,
        "phone_inner_interval": 0,
        "phone_circle_interval": 0,
        "phone_arrive_notice": False,
    },
    opts = pulumi.ResourceOptions(depends_on=[foo_monitor_tmp_tke_cluster_agent]))

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, "")
		defaultInstanceType := "SA1.MEDIUM2"
		if param := cfg.Get("defaultInstanceType"); param != "" {
			defaultInstanceType = param
		}
		availabilityZoneFirst := "ap-guangzhou-3"
		if param := cfg.Get("availabilityZoneFirst"); param != "" {
			availabilityZoneFirst = param
		}
		availabilityZoneSecond := "ap-guangzhou-4"
		if param := cfg.Get("availabilityZoneSecond"); param != "" {
			availabilityZoneSecond = param
		}
		exampleClusterCidr := "10.31.0.0/16"
		if param := cfg.Get("exampleClusterCidr"); param != "" {
			exampleClusterCidr = param
		}
		vpcOne, err := tencentcloud.GetVpcSubnets(ctx, &tencentcloud.GetVpcSubnetsArgs{
			IsDefault:        pulumi.BoolRef(true),
			AvailabilityZone: pulumi.StringRef(availabilityZoneFirst),
		}, nil)
		if err != nil {
			return err
		}
		firstVpcId := vpcOne.InstanceLists[0].VpcId
		firstSubnetId := vpcOne.InstanceLists[0].SubnetId
		vpcTwo, err := tencentcloud.GetVpcSubnets(ctx, &tencentcloud.GetVpcSubnetsArgs{
			IsDefault:        pulumi.BoolRef(true),
			AvailabilityZone: pulumi.StringRef(availabilityZoneSecond),
		}, nil)
		if err != nil {
			return err
		}
		_ := vpcTwo.InstanceLists[0].VpcId
		secondSubnetId := vpcTwo.InstanceLists[0].SubnetId
		sg, err := tencentcloud.NewSecurityGroup(ctx, "sg", nil)
		if err != nil {
			return err
		}
		sgId := sg.SecurityGroupId
		_default, err := tencentcloud.GetImages(ctx, &tencentcloud.GetImagesArgs{
			ImageTypes: []string{
				"PUBLIC_IMAGE",
			},
			ImageNameRegex: pulumi.StringRef("Final"),
		}, nil)
		if err != nil {
			return err
		}
		imageId := _default.ImageId
		_, err = tencentcloud.NewSecurityGroupLiteRule(ctx, "sgRule", &tencentcloud.SecurityGroupLiteRuleArgs{
			SecurityGroupId: sg.SecurityGroupId,
			Ingresses: pulumi.StringArray{
				pulumi.String("ACCEPT#10.0.0.0/16#ALL#ALL"),
				pulumi.String("ACCEPT#172.16.0.0/22#ALL#ALL"),
				pulumi.String("DROP#0.0.0.0/0#ALL#ALL"),
			},
			Egresses: pulumi.StringArray{
				pulumi.String("ACCEPT#172.16.0.0/22#ALL#ALL"),
			},
		})
		if err != nil {
			return err
		}
		example, err := tencentcloud.NewKubernetesCluster(ctx, "example", &tencentcloud.KubernetesClusterArgs{
			VpcId:                        pulumi.String(firstVpcId),
			ClusterCidr:                  pulumi.String(exampleClusterCidr),
			ClusterMaxPodNum:             pulumi.Float64(32),
			ClusterName:                  pulumi.String("tf_example_cluster"),
			ClusterDesc:                  pulumi.String("example for tke cluster"),
			ClusterMaxServiceNum:         pulumi.Float64(32),
			ClusterInternet:              pulumi.Bool(false),
			ClusterInternetSecurityGroup: pulumi.String(sgId),
			ClusterVersion:               pulumi.String("1.22.5"),
			ClusterDeployType:            pulumi.String("MANAGED_CLUSTER"),
			WorkerConfigs: tencentcloud.KubernetesClusterWorkerConfigArray{
				&tencentcloud.KubernetesClusterWorkerConfigArgs{
					Count:                   pulumi.Float64(1),
					AvailabilityZone:        pulumi.String(availabilityZoneFirst),
					InstanceType:            pulumi.String(defaultInstanceType),
					SystemDiskType:          pulumi.String("CLOUD_SSD"),
					SystemDiskSize:          pulumi.Float64(60),
					InternetChargeType:      pulumi.String("TRAFFIC_POSTPAID_BY_HOUR"),
					InternetMaxBandwidthOut: pulumi.Float64(100),
					PublicIpAssigned:        pulumi.Bool(true),
					SubnetId:                pulumi.String(firstSubnetId),
					ImgId:                   pulumi.String(imageId),
					DataDisks: tencentcloud.KubernetesClusterWorkerConfigDataDiskArray{
						&tencentcloud.KubernetesClusterWorkerConfigDataDiskArgs{
							DiskType: pulumi.String("CLOUD_PREMIUM"),
							DiskSize: pulumi.Float64(50),
						},
					},
					EnhancedSecurityService: pulumi.Bool(false),
					EnhancedMonitorService:  pulumi.Bool(false),
					UserData:                pulumi.String("dGVzdA=="),
					Password:                pulumi.String("ZZXXccvv1212"),
				},
				&tencentcloud.KubernetesClusterWorkerConfigArgs{
					Count:                   pulumi.Float64(1),
					AvailabilityZone:        pulumi.String(availabilityZoneSecond),
					InstanceType:            pulumi.String(defaultInstanceType),
					SystemDiskType:          pulumi.String("CLOUD_SSD"),
					SystemDiskSize:          pulumi.Float64(60),
					InternetChargeType:      pulumi.String("TRAFFIC_POSTPAID_BY_HOUR"),
					InternetMaxBandwidthOut: pulumi.Float64(100),
					PublicIpAssigned:        pulumi.Bool(true),
					SubnetId:                pulumi.String(secondSubnetId),
					DataDisks: tencentcloud.KubernetesClusterWorkerConfigDataDiskArray{
						&tencentcloud.KubernetesClusterWorkerConfigDataDiskArgs{
							DiskType: pulumi.String("CLOUD_PREMIUM"),
							DiskSize: pulumi.Float64(50),
						},
					},
					EnhancedSecurityService: pulumi.Bool(false),
					EnhancedMonitorService:  pulumi.Bool(false),
					UserData:                pulumi.String("dGVzdA=="),
					CamRoleName:             pulumi.String("CVM_QcsRole"),
					Password:                pulumi.String("ZZXXccvv1212"),
				},
			},
			Labels: pulumi.StringMap{
				"test1": pulumi.String("test1"),
				"test2": pulumi.String("test2"),
			},
		})
		if err != nil {
			return err
		}
		zone := "ap-guangzhou"
		if param := cfg.Get("zone"); param != "" {
			zone = param
		}
		clusterType := "tke"
		if param := cfg.Get("clusterType"); param != "" {
			clusterType = param
		}
		fooMonitorTmpInstance, err := tencentcloud.NewMonitorTmpInstance(ctx, "fooMonitorTmpInstance", &tencentcloud.MonitorTmpInstanceArgs{
			InstanceName:      pulumi.String("tf-tmp-instance"),
			VpcId:             pulumi.String(firstVpcId),
			SubnetId:          pulumi.String(firstSubnetId),
			DataRetentionTime: pulumi.Float64(30),
			Zone:              pulumi.String(availabilityZoneSecond),
			Tags: pulumi.StringMap{
				"createdBy": pulumi.String("terraform"),
			},
		})
		if err != nil {
			return err
		}
		// tmp tke bind
		fooMonitorTmpTkeClusterAgent, err := tencentcloud.NewMonitorTmpTkeClusterAgent(ctx, "fooMonitorTmpTkeClusterAgent", &tencentcloud.MonitorTmpTkeClusterAgentArgs{
			InstanceId: fooMonitorTmpInstance.MonitorTmpInstanceId,
			Agents: &tencentcloud.MonitorTmpTkeClusterAgentAgentsArgs{
				Region:         pulumi.String(zone),
				ClusterType:    pulumi.String(clusterType),
				ClusterId:      example.KubernetesClusterId,
				EnableExternal: pulumi.Bool(false),
			},
		})
		if err != nil {
			return err
		}
		// create record rule
		_, err = tencentcloud.NewMonitorTmpTkeGlobalNotification(ctx, "basic", &tencentcloud.MonitorTmpTkeGlobalNotificationArgs{
			InstanceId: fooMonitorTmpInstance.MonitorTmpInstanceId,
			Notification: &tencentcloud.MonitorTmpTkeGlobalNotificationNotificationArgs{
				Enabled: pulumi.Bool(true),
				Type:    pulumi.String("webhook"),
				AlertManagers: tencentcloud.MonitorTmpTkeGlobalNotificationNotificationAlertManagerArray{
					&tencentcloud.MonitorTmpTkeGlobalNotificationNotificationAlertManagerArgs{
						ClusterId:   pulumi.String(""),
						ClusterType: pulumi.String(""),
						Url:         pulumi.String(""),
					},
				},
				WebHook:        pulumi.String(""),
				RepeatInterval: pulumi.String("5m"),
				TimeRangeStart: pulumi.String("00:00:00"),
				TimeRangeEnd:   pulumi.String("23:59:59"),
				NotifyWays: pulumi.StringArray{
					pulumi.String("SMS"),
					pulumi.String("EMAIL"),
				},
				ReceiverGroups:      pulumi.StringArray{},
				PhoneNotifyOrders:   pulumi.Float64Array{},
				PhoneCircleTimes:    pulumi.Float64(0),
				PhoneInnerInterval:  pulumi.Float64(0),
				PhoneCircleInterval: pulumi.Float64(0),
				PhoneArriveNotice:   pulumi.Bool(false),
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			fooMonitorTmpTkeClusterAgent,
		}))
		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 defaultInstanceType = config.Get("defaultInstanceType") ?? "SA1.MEDIUM2";
    var availabilityZoneFirst = config.Get("availabilityZoneFirst") ?? "ap-guangzhou-3";
    var availabilityZoneSecond = config.Get("availabilityZoneSecond") ?? "ap-guangzhou-4";
    var exampleClusterCidr = config.Get("exampleClusterCidr") ?? "10.31.0.0/16";
    var vpcOne = Tencentcloud.GetVpcSubnets.Invoke(new()
    {
        IsDefault = true,
        AvailabilityZone = availabilityZoneFirst,
    });

    var firstVpcId = vpcOne.Apply(getVpcSubnetsResult => getVpcSubnetsResult.InstanceLists[0]?.VpcId);

    var firstSubnetId = vpcOne.Apply(getVpcSubnetsResult => getVpcSubnetsResult.InstanceLists[0]?.SubnetId);

    var vpcTwo = Tencentcloud.GetVpcSubnets.Invoke(new()
    {
        IsDefault = true,
        AvailabilityZone = availabilityZoneSecond,
    });

    var secondVpcId = vpcTwo.Apply(getVpcSubnetsResult => getVpcSubnetsResult.InstanceLists[0]?.VpcId);

    var secondSubnetId = vpcTwo.Apply(getVpcSubnetsResult => getVpcSubnetsResult.InstanceLists[0]?.SubnetId);

    var sg = new Tencentcloud.SecurityGroup("sg");

    var sgId = sg.SecurityGroupId;

    var @default = Tencentcloud.GetImages.Invoke(new()
    {
        ImageTypes = new[]
        {
            "PUBLIC_IMAGE",
        },
        ImageNameRegex = "Final",
    });

    var imageId = @default.Apply(@default => @default.Apply(getImagesResult => getImagesResult.ImageId));

    var sgRule = new Tencentcloud.SecurityGroupLiteRule("sgRule", new()
    {
        SecurityGroupId = sg.SecurityGroupId,
        Ingresses = new[]
        {
            "ACCEPT#10.0.0.0/16#ALL#ALL",
            "ACCEPT#172.16.0.0/22#ALL#ALL",
            "DROP#0.0.0.0/0#ALL#ALL",
        },
        Egresses = new[]
        {
            "ACCEPT#172.16.0.0/22#ALL#ALL",
        },
    });

    var example = new Tencentcloud.KubernetesCluster("example", new()
    {
        VpcId = firstVpcId,
        ClusterCidr = exampleClusterCidr,
        ClusterMaxPodNum = 32,
        ClusterName = "tf_example_cluster",
        ClusterDesc = "example for tke cluster",
        ClusterMaxServiceNum = 32,
        ClusterInternet = false,
        ClusterInternetSecurityGroup = sgId,
        ClusterVersion = "1.22.5",
        ClusterDeployType = "MANAGED_CLUSTER",
        WorkerConfigs = new[]
        {
            new Tencentcloud.Inputs.KubernetesClusterWorkerConfigArgs
            {
                Count = 1,
                AvailabilityZone = availabilityZoneFirst,
                InstanceType = defaultInstanceType,
                SystemDiskType = "CLOUD_SSD",
                SystemDiskSize = 60,
                InternetChargeType = "TRAFFIC_POSTPAID_BY_HOUR",
                InternetMaxBandwidthOut = 100,
                PublicIpAssigned = true,
                SubnetId = firstSubnetId,
                ImgId = imageId,
                DataDisks = new[]
                {
                    new Tencentcloud.Inputs.KubernetesClusterWorkerConfigDataDiskArgs
                    {
                        DiskType = "CLOUD_PREMIUM",
                        DiskSize = 50,
                    },
                },
                EnhancedSecurityService = false,
                EnhancedMonitorService = false,
                UserData = "dGVzdA==",
                Password = "ZZXXccvv1212",
            },
            new Tencentcloud.Inputs.KubernetesClusterWorkerConfigArgs
            {
                Count = 1,
                AvailabilityZone = availabilityZoneSecond,
                InstanceType = defaultInstanceType,
                SystemDiskType = "CLOUD_SSD",
                SystemDiskSize = 60,
                InternetChargeType = "TRAFFIC_POSTPAID_BY_HOUR",
                InternetMaxBandwidthOut = 100,
                PublicIpAssigned = true,
                SubnetId = secondSubnetId,
                DataDisks = new[]
                {
                    new Tencentcloud.Inputs.KubernetesClusterWorkerConfigDataDiskArgs
                    {
                        DiskType = "CLOUD_PREMIUM",
                        DiskSize = 50,
                    },
                },
                EnhancedSecurityService = false,
                EnhancedMonitorService = false,
                UserData = "dGVzdA==",
                CamRoleName = "CVM_QcsRole",
                Password = "ZZXXccvv1212",
            },
        },
        Labels = 
        {
            { "test1", "test1" },
            { "test2", "test2" },
        },
    });

    var zone = config.Get("zone") ?? "ap-guangzhou";
    var clusterType = config.Get("clusterType") ?? "tke";
    var fooMonitorTmpInstance = new Tencentcloud.MonitorTmpInstance("fooMonitorTmpInstance", new()
    {
        InstanceName = "tf-tmp-instance",
        VpcId = firstVpcId,
        SubnetId = firstSubnetId,
        DataRetentionTime = 30,
        Zone = availabilityZoneSecond,
        Tags = 
        {
            { "createdBy", "terraform" },
        },
    });

    // tmp tke bind
    var fooMonitorTmpTkeClusterAgent = new Tencentcloud.MonitorTmpTkeClusterAgent("fooMonitorTmpTkeClusterAgent", new()
    {
        InstanceId = fooMonitorTmpInstance.MonitorTmpInstanceId,
        Agents = new Tencentcloud.Inputs.MonitorTmpTkeClusterAgentAgentsArgs
        {
            Region = zone,
            ClusterType = clusterType,
            ClusterId = example.KubernetesClusterId,
            EnableExternal = false,
        },
    });

    // create record rule
    var basic = new Tencentcloud.MonitorTmpTkeGlobalNotification("basic", new()
    {
        InstanceId = fooMonitorTmpInstance.MonitorTmpInstanceId,
        Notification = new Tencentcloud.Inputs.MonitorTmpTkeGlobalNotificationNotificationArgs
        {
            Enabled = true,
            Type = "webhook",
            AlertManagers = new[]
            {
                new Tencentcloud.Inputs.MonitorTmpTkeGlobalNotificationNotificationAlertManagerArgs
                {
                    ClusterId = "",
                    ClusterType = "",
                    Url = "",
                },
            },
            WebHook = "",
            RepeatInterval = "5m",
            TimeRangeStart = "00:00:00",
            TimeRangeEnd = "23:59:59",
            NotifyWays = new[]
            {
                "SMS",
                "EMAIL",
            },
            ReceiverGroups = new() { },
            PhoneNotifyOrders = new() { },
            PhoneCircleTimes = 0,
            PhoneInnerInterval = 0,
            PhoneCircleInterval = 0,
            PhoneArriveNotice = false,
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            fooMonitorTmpTkeClusterAgent,
        },
    });

});

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.GetVpcSubnetsArgs;
import com.pulumi.tencentcloud.SecurityGroup;
import com.pulumi.tencentcloud.inputs.GetImagesArgs;
import com.pulumi.tencentcloud.SecurityGroupLiteRule;
import com.pulumi.tencentcloud.SecurityGroupLiteRuleArgs;
import com.pulumi.tencentcloud.KubernetesCluster;
import com.pulumi.tencentcloud.KubernetesClusterArgs;
import com.pulumi.tencentcloud.inputs.KubernetesClusterWorkerConfigArgs;
import com.pulumi.tencentcloud.MonitorTmpInstance;
import com.pulumi.tencentcloud.MonitorTmpInstanceArgs;
import com.pulumi.tencentcloud.MonitorTmpTkeClusterAgent;
import com.pulumi.tencentcloud.MonitorTmpTkeClusterAgentArgs;
import com.pulumi.tencentcloud.inputs.MonitorTmpTkeClusterAgentAgentsArgs;
import com.pulumi.tencentcloud.MonitorTmpTkeGlobalNotification;
import com.pulumi.tencentcloud.MonitorTmpTkeGlobalNotificationArgs;
import com.pulumi.tencentcloud.inputs.MonitorTmpTkeGlobalNotificationNotificationArgs;
import com.pulumi.resources.CustomResourceOptions;
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 defaultInstanceType = config.get("defaultInstanceType").orElse("SA1.MEDIUM2");
        final var availabilityZoneFirst = config.get("availabilityZoneFirst").orElse("ap-guangzhou-3");
        final var availabilityZoneSecond = config.get("availabilityZoneSecond").orElse("ap-guangzhou-4");
        final var exampleClusterCidr = config.get("exampleClusterCidr").orElse("10.31.0.0/16");
        final var vpcOne = TencentcloudFunctions.getVpcSubnets(GetVpcSubnetsArgs.builder()
            .isDefault(true)
            .availabilityZone(availabilityZoneFirst)
            .build());

        final var firstVpcId = vpcOne.applyValue(getVpcSubnetsResult -> getVpcSubnetsResult.instanceLists()[0].vpcId());

        final var firstSubnetId = vpcOne.applyValue(getVpcSubnetsResult -> getVpcSubnetsResult.instanceLists()[0].subnetId());

        final var vpcTwo = TencentcloudFunctions.getVpcSubnets(GetVpcSubnetsArgs.builder()
            .isDefault(true)
            .availabilityZone(availabilityZoneSecond)
            .build());

        final var secondVpcId = vpcTwo.applyValue(getVpcSubnetsResult -> getVpcSubnetsResult.instanceLists()[0].vpcId());

        final var secondSubnetId = vpcTwo.applyValue(getVpcSubnetsResult -> getVpcSubnetsResult.instanceLists()[0].subnetId());

        var sg = new SecurityGroup("sg");

        final var sgId = sg.securityGroupId();

        final var default = TencentcloudFunctions.getImages(GetImagesArgs.builder()
            .imageTypes("PUBLIC_IMAGE")
            .imageNameRegex("Final")
            .build());

        final var imageId = default_.imageId();

        var sgRule = new SecurityGroupLiteRule("sgRule", SecurityGroupLiteRuleArgs.builder()
            .securityGroupId(sg.securityGroupId())
            .ingresses(            
                "ACCEPT#10.0.0.0/16#ALL#ALL",
                "ACCEPT#172.16.0.0/22#ALL#ALL",
                "DROP#0.0.0.0/0#ALL#ALL")
            .egresses("ACCEPT#172.16.0.0/22#ALL#ALL")
            .build());

        var example = new KubernetesCluster("example", KubernetesClusterArgs.builder()
            .vpcId(firstVpcId)
            .clusterCidr(exampleClusterCidr)
            .clusterMaxPodNum(32)
            .clusterName("tf_example_cluster")
            .clusterDesc("example for tke cluster")
            .clusterMaxServiceNum(32)
            .clusterInternet(false)
            .clusterInternetSecurityGroup(sgId)
            .clusterVersion("1.22.5")
            .clusterDeployType("MANAGED_CLUSTER")
            .workerConfigs(            
                KubernetesClusterWorkerConfigArgs.builder()
                    .count(1)
                    .availabilityZone(availabilityZoneFirst)
                    .instanceType(defaultInstanceType)
                    .systemDiskType("CLOUD_SSD")
                    .systemDiskSize(60)
                    .internetChargeType("TRAFFIC_POSTPAID_BY_HOUR")
                    .internetMaxBandwidthOut(100)
                    .publicIpAssigned(true)
                    .subnetId(firstSubnetId)
                    .imgId(imageId)
                    .dataDisks(KubernetesClusterWorkerConfigDataDiskArgs.builder()
                        .diskType("CLOUD_PREMIUM")
                        .diskSize(50)
                        .build())
                    .enhancedSecurityService(false)
                    .enhancedMonitorService(false)
                    .userData("dGVzdA==")
                    .password("ZZXXccvv1212")
                    .build(),
                KubernetesClusterWorkerConfigArgs.builder()
                    .count(1)
                    .availabilityZone(availabilityZoneSecond)
                    .instanceType(defaultInstanceType)
                    .systemDiskType("CLOUD_SSD")
                    .systemDiskSize(60)
                    .internetChargeType("TRAFFIC_POSTPAID_BY_HOUR")
                    .internetMaxBandwidthOut(100)
                    .publicIpAssigned(true)
                    .subnetId(secondSubnetId)
                    .dataDisks(KubernetesClusterWorkerConfigDataDiskArgs.builder()
                        .diskType("CLOUD_PREMIUM")
                        .diskSize(50)
                        .build())
                    .enhancedSecurityService(false)
                    .enhancedMonitorService(false)
                    .userData("dGVzdA==")
                    .camRoleName("CVM_QcsRole")
                    .password("ZZXXccvv1212")
                    .build())
            .labels(Map.ofEntries(
                Map.entry("test1", "test1"),
                Map.entry("test2", "test2")
            ))
            .build());

        final var zone = config.get("zone").orElse("ap-guangzhou");
        final var clusterType = config.get("clusterType").orElse("tke");
        var fooMonitorTmpInstance = new MonitorTmpInstance("fooMonitorTmpInstance", MonitorTmpInstanceArgs.builder()
            .instanceName("tf-tmp-instance")
            .vpcId(firstVpcId)
            .subnetId(firstSubnetId)
            .dataRetentionTime(30)
            .zone(availabilityZoneSecond)
            .tags(Map.of("createdBy", "terraform"))
            .build());

        // tmp tke bind
        var fooMonitorTmpTkeClusterAgent = new MonitorTmpTkeClusterAgent("fooMonitorTmpTkeClusterAgent", MonitorTmpTkeClusterAgentArgs.builder()
            .instanceId(fooMonitorTmpInstance.monitorTmpInstanceId())
            .agents(MonitorTmpTkeClusterAgentAgentsArgs.builder()
                .region(zone)
                .clusterType(clusterType)
                .clusterId(example.kubernetesClusterId())
                .enableExternal(false)
                .build())
            .build());

        // create record rule
        var basic = new MonitorTmpTkeGlobalNotification("basic", MonitorTmpTkeGlobalNotificationArgs.builder()
            .instanceId(fooMonitorTmpInstance.monitorTmpInstanceId())
            .notification(MonitorTmpTkeGlobalNotificationNotificationArgs.builder()
                .enabled(true)
                .type("webhook")
                .alertManagers(MonitorTmpTkeGlobalNotificationNotificationAlertManagerArgs.builder()
                    .clusterId("")
                    .clusterType("")
                    .url("")
                    .build())
                .webHook("")
                .repeatInterval("5m")
                .timeRangeStart("00:00:00")
                .timeRangeEnd("23:59:59")
                .notifyWays(                
                    "SMS",
                    "EMAIL")
                .receiverGroups()
                .phoneNotifyOrders()
                .phoneCircleTimes(0)
                .phoneInnerInterval(0)
                .phoneCircleInterval(0)
                .phoneArriveNotice(false)
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(fooMonitorTmpTkeClusterAgent)
                .build());

    }
}

configuration:
  defaultInstanceType:
    type: string
    default: SA1.MEDIUM2
  availabilityZoneFirst:
    type: string
    default: ap-guangzhou-3
  availabilityZoneSecond:
    type: string
    default: ap-guangzhou-4
  exampleClusterCidr:
    type: string
    default: 10.31.0.0/16
  # create monitor
  zone:
    type: string
    default: ap-guangzhou
  clusterType:
    type: string
    default: tke
resources:
  sg:
    type: tencentcloud:SecurityGroup
  sgRule:
    type: tencentcloud:SecurityGroupLiteRule
    properties:
      securityGroupId: ${sg.securityGroupId}
      ingresses:
        - ACCEPT#10.0.0.0/16#ALL#ALL
        - ACCEPT#172.16.0.0/22#ALL#ALL
        - DROP#0.0.0.0/0#ALL#ALL
      egresses:
        - ACCEPT#172.16.0.0/22#ALL#ALL
  example:
    type: tencentcloud:KubernetesCluster
    properties:
      vpcId: ${firstVpcId}
      clusterCidr: ${exampleClusterCidr}
      clusterMaxPodNum: 32
      clusterName: tf_example_cluster
      clusterDesc: example for tke cluster
      clusterMaxServiceNum: 32
      clusterInternet: false
      clusterInternetSecurityGroup: ${sgId}
      clusterVersion: 1.22.5
      clusterDeployType: MANAGED_CLUSTER
      workerConfigs:
        - count: 1
          availabilityZone: ${availabilityZoneFirst}
          instanceType: ${defaultInstanceType}
          systemDiskType: CLOUD_SSD
          systemDiskSize: 60
          internetChargeType: TRAFFIC_POSTPAID_BY_HOUR
          internetMaxBandwidthOut: 100
          publicIpAssigned: true
          subnetId: ${firstSubnetId}
          imgId: ${imageId}
          dataDisks:
            - diskType: CLOUD_PREMIUM
              diskSize: 50
          enhancedSecurityService: false
          enhancedMonitorService: false
          userData: dGVzdA==
          password: ZZXXccvv1212
        - count: 1
          availabilityZone: ${availabilityZoneSecond}
          instanceType: ${defaultInstanceType}
          systemDiskType: CLOUD_SSD
          systemDiskSize: 60
          internetChargeType: TRAFFIC_POSTPAID_BY_HOUR
          internetMaxBandwidthOut: 100
          publicIpAssigned: true
          subnetId: ${secondSubnetId}
          dataDisks:
            - diskType: CLOUD_PREMIUM
              diskSize: 50
          enhancedSecurityService: false
          enhancedMonitorService: false
          userData: dGVzdA==
          camRoleName: CVM_QcsRole
          password: ZZXXccvv1212
      labels:
        test1: test1
        test2: test2
  fooMonitorTmpInstance:
    type: tencentcloud:MonitorTmpInstance
    properties:
      instanceName: tf-tmp-instance
      vpcId: ${firstVpcId}
      subnetId: ${firstSubnetId}
      dataRetentionTime: 30
      zone: ${availabilityZoneSecond}
      tags:
        createdBy: terraform
  # tmp tke bind
  fooMonitorTmpTkeClusterAgent:
    type: tencentcloud:MonitorTmpTkeClusterAgent
    properties:
      instanceId: ${fooMonitorTmpInstance.monitorTmpInstanceId}
      agents:
        region: ${zone}
        clusterType: ${clusterType}
        clusterId: ${example.kubernetesClusterId}
        enableExternal: false
  # create record rule
  basic:
    type: tencentcloud:MonitorTmpTkeGlobalNotification
    properties:
      instanceId: ${fooMonitorTmpInstance.monitorTmpInstanceId}
      notification:
        enabled: true
        type: webhook
        alertManagers:
          - clusterId: ""
            clusterType: ""
            url: ""
        webHook: ""
        repeatInterval: 5m
        timeRangeStart: 00:00:00
        timeRangeEnd: 23:59:59
        notifyWays:
          - SMS
          - EMAIL
        receiverGroups: []
        phoneNotifyOrders: []
        phoneCircleTimes: 0
        phoneInnerInterval: 0
        phoneCircleInterval: 0
        phoneArriveNotice: false
    options:
      dependsOn:
        - ${fooMonitorTmpTkeClusterAgent}
variables:
  firstVpcId: ${vpcOne.instanceLists[0].vpcId}
  firstSubnetId: ${vpcOne.instanceLists[0].subnetId}
  secondVpcId: ${vpcTwo.instanceLists[0].vpcId}
  secondSubnetId: ${vpcTwo.instanceLists[0].subnetId}
  sgId: ${sg.securityGroupId}
  imageId: ${default.imageId}
  vpcOne:
    fn::invoke:
      function: tencentcloud:getVpcSubnets
      arguments:
        isDefault: true
        availabilityZone: ${availabilityZoneFirst}
  vpcTwo:
    fn::invoke:
      function: tencentcloud:getVpcSubnets
      arguments:
        isDefault: true
        availabilityZone: ${availabilityZoneSecond}
  default:
    fn::invoke:
      function: tencentcloud:getImages
      arguments:
        imageTypes:
          - PUBLIC_IMAGE
        imageNameRegex: Final