tencentcloud.KubernetesClusterAttachment

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

const config = new pulumi.Config();
const availabilityZone = config.get("availabilityZone") || "ap-guangzhou-3";
const clusterCidr = config.get("clusterCidr") || "172.16.0.0/16";
const defaultInstanceType = config.get("defaultInstanceType") || "S1.SMALL1";
const defaultImages = tencentcloud.getImages({
    imageTypes: ["PUBLIC_IMAGE"],
    osName: "centos",
});
const vpc = tencentcloud.getVpcSubnets({
    isDefault: true,
    availabilityZone: availabilityZone,
});
const defaultInstanceTypes = tencentcloud.getInstanceTypes({
    filters: [{
        name: "instance-family",
        values: ["SA2"],
    }],
    cpuCoreCount: 8,
    memorySize: 16,
});
const foo = new tencentcloud.Instance("foo", {
    instanceName: "tf-auto-test-1-1",
    availabilityZone: availabilityZone,
    imageId: defaultImages.then(defaultImages => defaultImages.images?.[0]?.imageId),
    instanceType: defaultInstanceType,
    systemDiskType: "CLOUD_PREMIUM",
    systemDiskSize: 50,
});
const managedCluster = new tencentcloud.KubernetesCluster("managedCluster", {
    vpcId: vpc.then(vpc => vpc.instanceLists?.[0]?.vpcId),
    clusterCidr: "10.1.0.0/16",
    clusterMaxPodNum: 32,
    clusterName: "keep",
    clusterDesc: "test cluster desc",
    clusterMaxServiceNum: 32,
    workerConfigs: [{
        count: 1,
        availabilityZone: availabilityZone,
        instanceType: defaultInstanceType,
        systemDiskType: "CLOUD_SSD",
        systemDiskSize: 60,
        internetChargeType: "TRAFFIC_POSTPAID_BY_HOUR",
        internetMaxBandwidthOut: 100,
        publicIpAssigned: true,
        subnetId: vpc.then(vpc => vpc.instanceLists?.[0]?.subnetId),
        dataDisks: [{
            diskType: "CLOUD_PREMIUM",
            diskSize: 50,
        }],
        enhancedSecurityService: false,
        enhancedMonitorService: false,
        userData: "dGVzdA==",
        password: "ZZXXccvv1212",
    }],
    clusterDeployType: "MANAGED_CLUSTER",
});
const testAttach = new tencentcloud.KubernetesClusterAttachment("testAttach", {
    clusterId: managedCluster.kubernetesClusterId,
    instanceId: foo.instanceId,
    password: "Lo4wbdit",
    labels: {
        test1: "test1",
        test2: "test2",
    },
    workerConfigOverrides: {
        desiredPodNum: 8,
    },
});

import pulumi
import pulumi_tencentcloud as tencentcloud

config = pulumi.Config()
availability_zone = config.get("availabilityZone")
if availability_zone is None:
    availability_zone = "ap-guangzhou-3"
cluster_cidr = config.get("clusterCidr")
if cluster_cidr is None:
    cluster_cidr = "172.16.0.0/16"
default_instance_type = config.get("defaultInstanceType")
if default_instance_type is None:
    default_instance_type = "S1.SMALL1"
default_images = tencentcloud.get_images(image_types=["PUBLIC_IMAGE"],
    os_name="centos")
vpc = tencentcloud.get_vpc_subnets(is_default=True,
    availability_zone=availability_zone)
default_instance_types = tencentcloud.get_instance_types(filters=[{
        "name": "instance-family",
        "values": ["SA2"],
    }],
    cpu_core_count=8,
    memory_size=16)
foo = tencentcloud.Instance("foo",
    instance_name="tf-auto-test-1-1",
    availability_zone=availability_zone,
    image_id=default_images.images[0].image_id,
    instance_type=default_instance_type,
    system_disk_type="CLOUD_PREMIUM",
    system_disk_size=50)
managed_cluster = tencentcloud.KubernetesCluster("managedCluster",
    vpc_id=vpc.instance_lists[0].vpc_id,
    cluster_cidr="10.1.0.0/16",
    cluster_max_pod_num=32,
    cluster_name="keep",
    cluster_desc="test cluster desc",
    cluster_max_service_num=32,
    worker_configs=[{
        "count": 1,
        "availability_zone": availability_zone,
        "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": vpc.instance_lists[0].subnet_id,
        "data_disks": [{
            "disk_type": "CLOUD_PREMIUM",
            "disk_size": 50,
        }],
        "enhanced_security_service": False,
        "enhanced_monitor_service": False,
        "user_data": "dGVzdA==",
        "password": "ZZXXccvv1212",
    }],
    cluster_deploy_type="MANAGED_CLUSTER")
test_attach = tencentcloud.KubernetesClusterAttachment("testAttach",
    cluster_id=managed_cluster.kubernetes_cluster_id,
    instance_id=foo.instance_id,
    password="Lo4wbdit",
    labels={
        "test1": "test1",
        "test2": "test2",
    },
    worker_config_overrides={
        "desired_pod_num": 8,
    })

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, "")
		availabilityZone := "ap-guangzhou-3"
		if param := cfg.Get("availabilityZone"); param != "" {
			availabilityZone = param
		}
		clusterCidr := "172.16.0.0/16"
		if param := cfg.Get("clusterCidr"); param != "" {
			clusterCidr = param
		}
		defaultInstanceType := "S1.SMALL1"
		if param := cfg.Get("defaultInstanceType"); param != "" {
			defaultInstanceType = param
		}
		defaultImages, err := tencentcloud.GetImages(ctx, &tencentcloud.GetImagesArgs{
			ImageTypes: []string{
				"PUBLIC_IMAGE",
			},
			OsName: pulumi.StringRef("centos"),
		}, nil)
		if err != nil {
			return err
		}
		vpc, err := tencentcloud.GetVpcSubnets(ctx, &tencentcloud.GetVpcSubnetsArgs{
			IsDefault:        pulumi.BoolRef(true),
			AvailabilityZone: pulumi.StringRef(availabilityZone),
		}, nil)
		if err != nil {
			return err
		}
		_, err = tencentcloud.GetInstanceTypes(ctx, &tencentcloud.GetInstanceTypesArgs{
			Filters: []tencentcloud.GetInstanceTypesFilter{
				{
					Name: "instance-family",
					Values: []string{
						"SA2",
					},
				},
			},
			CpuCoreCount: pulumi.Float64Ref(8),
			MemorySize:   pulumi.Float64Ref(16),
		}, nil)
		if err != nil {
			return err
		}
		foo, err := tencentcloud.NewInstance(ctx, "foo", &tencentcloud.InstanceArgs{
			InstanceName:     pulumi.String("tf-auto-test-1-1"),
			AvailabilityZone: pulumi.String(availabilityZone),
			ImageId:          pulumi.String(defaultImages.Images[0].ImageId),
			InstanceType:     pulumi.String(defaultInstanceType),
			SystemDiskType:   pulumi.String("CLOUD_PREMIUM"),
			SystemDiskSize:   pulumi.Float64(50),
		})
		if err != nil {
			return err
		}
		managedCluster, err := tencentcloud.NewKubernetesCluster(ctx, "managedCluster", &tencentcloud.KubernetesClusterArgs{
			VpcId:                pulumi.String(vpc.InstanceLists[0].VpcId),
			ClusterCidr:          pulumi.String("10.1.0.0/16"),
			ClusterMaxPodNum:     pulumi.Float64(32),
			ClusterName:          pulumi.String("keep"),
			ClusterDesc:          pulumi.String("test cluster desc"),
			ClusterMaxServiceNum: pulumi.Float64(32),
			WorkerConfigs: tencentcloud.KubernetesClusterWorkerConfigArray{
				&tencentcloud.KubernetesClusterWorkerConfigArgs{
					Count:                   pulumi.Float64(1),
					AvailabilityZone:        pulumi.String(availabilityZone),
					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(vpc.InstanceLists[0].SubnetId),
					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"),
				},
			},
			ClusterDeployType: pulumi.String("MANAGED_CLUSTER"),
		})
		if err != nil {
			return err
		}
		_, err = tencentcloud.NewKubernetesClusterAttachment(ctx, "testAttach", &tencentcloud.KubernetesClusterAttachmentArgs{
			ClusterId:  managedCluster.KubernetesClusterId,
			InstanceId: foo.InstanceId,
			Password:   pulumi.String("Lo4wbdit"),
			Labels: pulumi.StringMap{
				"test1": pulumi.String("test1"),
				"test2": pulumi.String("test2"),
			},
			WorkerConfigOverrides: &tencentcloud.KubernetesClusterAttachmentWorkerConfigOverridesArgs{
				DesiredPodNum: pulumi.Float64(8),
			},
		})
		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 availabilityZone = config.Get("availabilityZone") ?? "ap-guangzhou-3";
    var clusterCidr = config.Get("clusterCidr") ?? "172.16.0.0/16";
    var defaultInstanceType = config.Get("defaultInstanceType") ?? "S1.SMALL1";
    var defaultImages = Tencentcloud.GetImages.Invoke(new()
    {
        ImageTypes = new[]
        {
            "PUBLIC_IMAGE",
        },
        OsName = "centos",
    });

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

    var defaultInstanceTypes = Tencentcloud.GetInstanceTypes.Invoke(new()
    {
        Filters = new[]
        {
            new Tencentcloud.Inputs.GetInstanceTypesFilterInputArgs
            {
                Name = "instance-family",
                Values = new[]
                {
                    "SA2",
                },
            },
        },
        CpuCoreCount = 8,
        MemorySize = 16,
    });

    var foo = new Tencentcloud.Instance("foo", new()
    {
        InstanceName = "tf-auto-test-1-1",
        AvailabilityZone = availabilityZone,
        ImageId = defaultImages.Apply(getImagesResult => getImagesResult.Images[0]?.ImageId),
        InstanceType = defaultInstanceType,
        SystemDiskType = "CLOUD_PREMIUM",
        SystemDiskSize = 50,
    });

    var managedCluster = new Tencentcloud.KubernetesCluster("managedCluster", new()
    {
        VpcId = vpc.Apply(getVpcSubnetsResult => getVpcSubnetsResult.InstanceLists[0]?.VpcId),
        ClusterCidr = "10.1.0.0/16",
        ClusterMaxPodNum = 32,
        ClusterName = "keep",
        ClusterDesc = "test cluster desc",
        ClusterMaxServiceNum = 32,
        WorkerConfigs = new[]
        {
            new Tencentcloud.Inputs.KubernetesClusterWorkerConfigArgs
            {
                Count = 1,
                AvailabilityZone = availabilityZone,
                InstanceType = defaultInstanceType,
                SystemDiskType = "CLOUD_SSD",
                SystemDiskSize = 60,
                InternetChargeType = "TRAFFIC_POSTPAID_BY_HOUR",
                InternetMaxBandwidthOut = 100,
                PublicIpAssigned = true,
                SubnetId = vpc.Apply(getVpcSubnetsResult => getVpcSubnetsResult.InstanceLists[0]?.SubnetId),
                DataDisks = new[]
                {
                    new Tencentcloud.Inputs.KubernetesClusterWorkerConfigDataDiskArgs
                    {
                        DiskType = "CLOUD_PREMIUM",
                        DiskSize = 50,
                    },
                },
                EnhancedSecurityService = false,
                EnhancedMonitorService = false,
                UserData = "dGVzdA==",
                Password = "ZZXXccvv1212",
            },
        },
        ClusterDeployType = "MANAGED_CLUSTER",
    });

    var testAttach = new Tencentcloud.KubernetesClusterAttachment("testAttach", new()
    {
        ClusterId = managedCluster.KubernetesClusterId,
        InstanceId = foo.InstanceId,
        Password = "Lo4wbdit",
        Labels = 
        {
            { "test1", "test1" },
            { "test2", "test2" },
        },
        WorkerConfigOverrides = new Tencentcloud.Inputs.KubernetesClusterAttachmentWorkerConfigOverridesArgs
        {
            DesiredPodNum = 8,
        },
    });

});

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.GetImagesArgs;
import com.pulumi.tencentcloud.inputs.GetVpcSubnetsArgs;
import com.pulumi.tencentcloud.inputs.GetInstanceTypesArgs;
import com.pulumi.tencentcloud.Instance;
import com.pulumi.tencentcloud.InstanceArgs;
import com.pulumi.tencentcloud.KubernetesCluster;
import com.pulumi.tencentcloud.KubernetesClusterArgs;
import com.pulumi.tencentcloud.inputs.KubernetesClusterWorkerConfigArgs;
import com.pulumi.tencentcloud.KubernetesClusterAttachment;
import com.pulumi.tencentcloud.KubernetesClusterAttachmentArgs;
import com.pulumi.tencentcloud.inputs.KubernetesClusterAttachmentWorkerConfigOverridesArgs;
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 availabilityZone = config.get("availabilityZone").orElse("ap-guangzhou-3");
        final var clusterCidr = config.get("clusterCidr").orElse("172.16.0.0/16");
        final var defaultInstanceType = config.get("defaultInstanceType").orElse("S1.SMALL1");
        final var defaultImages = TencentcloudFunctions.getImages(GetImagesArgs.builder()
            .imageTypes("PUBLIC_IMAGE")
            .osName("centos")
            .build());

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

        final var defaultInstanceTypes = TencentcloudFunctions.getInstanceTypes(GetInstanceTypesArgs.builder()
            .filters(GetInstanceTypesFilterArgs.builder()
                .name("instance-family")
                .values("SA2")
                .build())
            .cpuCoreCount(8)
            .memorySize(16)
            .build());

        var foo = new Instance("foo", InstanceArgs.builder()
            .instanceName("tf-auto-test-1-1")
            .availabilityZone(availabilityZone)
            .imageId(defaultImages.applyValue(getImagesResult -> getImagesResult.images()[0].imageId()))
            .instanceType(defaultInstanceType)
            .systemDiskType("CLOUD_PREMIUM")
            .systemDiskSize(50)
            .build());

        var managedCluster = new KubernetesCluster("managedCluster", KubernetesClusterArgs.builder()
            .vpcId(vpc.applyValue(getVpcSubnetsResult -> getVpcSubnetsResult.instanceLists()[0].vpcId()))
            .clusterCidr("10.1.0.0/16")
            .clusterMaxPodNum(32)
            .clusterName("keep")
            .clusterDesc("test cluster desc")
            .clusterMaxServiceNum(32)
            .workerConfigs(KubernetesClusterWorkerConfigArgs.builder()
                .count(1)
                .availabilityZone(availabilityZone)
                .instanceType(defaultInstanceType)
                .systemDiskType("CLOUD_SSD")
                .systemDiskSize(60)
                .internetChargeType("TRAFFIC_POSTPAID_BY_HOUR")
                .internetMaxBandwidthOut(100)
                .publicIpAssigned(true)
                .subnetId(vpc.applyValue(getVpcSubnetsResult -> getVpcSubnetsResult.instanceLists()[0].subnetId()))
                .dataDisks(KubernetesClusterWorkerConfigDataDiskArgs.builder()
                    .diskType("CLOUD_PREMIUM")
                    .diskSize(50)
                    .build())
                .enhancedSecurityService(false)
                .enhancedMonitorService(false)
                .userData("dGVzdA==")
                .password("ZZXXccvv1212")
                .build())
            .clusterDeployType("MANAGED_CLUSTER")
            .build());

        var testAttach = new KubernetesClusterAttachment("testAttach", KubernetesClusterAttachmentArgs.builder()
            .clusterId(managedCluster.kubernetesClusterId())
            .instanceId(foo.instanceId())
            .password("Lo4wbdit")
            .labels(Map.ofEntries(
                Map.entry("test1", "test1"),
                Map.entry("test2", "test2")
            ))
            .workerConfigOverrides(KubernetesClusterAttachmentWorkerConfigOverridesArgs.builder()
                .desiredPodNum(8)
                .build())
            .build());

    }
}

configuration:
  availabilityZone:
    type: string
    default: ap-guangzhou-3
  clusterCidr:
    type: string
    default: 172.16.0.0/16
  defaultInstanceType:
    type: string
    default: S1.SMALL1
resources:
  foo:
    type: tencentcloud:Instance
    properties:
      instanceName: tf-auto-test-1-1
      availabilityZone: ${availabilityZone}
      imageId: ${defaultImages.images[0].imageId}
      instanceType: ${defaultInstanceType}
      systemDiskType: CLOUD_PREMIUM
      systemDiskSize: 50
  managedCluster:
    type: tencentcloud:KubernetesCluster
    properties:
      vpcId: ${vpc.instanceLists[0].vpcId}
      clusterCidr: 10.1.0.0/16
      clusterMaxPodNum: 32
      clusterName: keep
      clusterDesc: test cluster desc
      clusterMaxServiceNum: 32
      workerConfigs:
        - count: 1
          availabilityZone: ${availabilityZone}
          instanceType: ${defaultInstanceType}
          systemDiskType: CLOUD_SSD
          systemDiskSize: 60
          internetChargeType: TRAFFIC_POSTPAID_BY_HOUR
          internetMaxBandwidthOut: 100
          publicIpAssigned: true
          subnetId: ${vpc.instanceLists[0].subnetId}
          dataDisks:
            - diskType: CLOUD_PREMIUM
              diskSize: 50
          enhancedSecurityService: false
          enhancedMonitorService: false
          userData: dGVzdA==
          password: ZZXXccvv1212
      clusterDeployType: MANAGED_CLUSTER
  testAttach:
    type: tencentcloud:KubernetesClusterAttachment
    properties:
      clusterId: ${managedCluster.kubernetesClusterId}
      instanceId: ${foo.instanceId}
      password: Lo4wbdit
      labels:
        test1: test1
        test2: test2
      workerConfigOverrides:
        desiredPodNum: 8
variables:
  defaultImages:
    fn::invoke:
      function: tencentcloud:getImages
      arguments:
        imageTypes:
          - PUBLIC_IMAGE
        osName: centos
  vpc:
    fn::invoke:
      function: tencentcloud:getVpcSubnets
      arguments:
        isDefault: true
        availabilityZone: ${availabilityZone}
  defaultInstanceTypes:
    fn::invoke:
      function: tencentcloud:getInstanceTypes
      arguments:
        filters:
          - name: instance-family
            values:
              - SA2
        cpuCoreCount: 8
        memorySize: 16