创建节点池¶

from tencentcloud.common import credential
from tencentcloud.common.profile.client_profile import ClientProfile
from tencentcloud.common.profile.http_profile import HttpProfile
from tencentcloud.tke.v20180525 import tke_client, models
import json
import time

def create_nodepool(cluster_id, nodepool_name, vpc_id, subnet_ids, 
                    instance_type, desired_capacity=3, min_size=1, max_size=10):
    """
    创建节点池

    Args:
        cluster_id: 集群 ID
        nodepool_name: 节点池名称
        vpc_id: VPC ID
        subnet_ids: 子网 ID 列表
        instance_type: 实例规格
        desired_capacity: 期望节点数
        min_size: 最小节点数
        max_size: 最大节点数
    """
    print(f"正在创建节点池: {nodepool_name}")
    print(f"集群 ID: {cluster_id}")
    print(f"实例规格: {instance_type}")
    print(f"期望节点数: {desired_capacity}")

    # 初始化客户端
    cred = credential.EnvironmentVariableCredential()
    httpProfile = HttpProfile()
    httpProfile.endpoint = "tke.tencentcloudapi.com"

    clientProfile = ClientProfile()
    clientProfile.httpProfile = httpProfile

    client = tke_client.TkeClient(cred, "ap-guangzhou", clientProfile)

    # 构建请求
    request = models.CreateNodePoolRequest()
    request.ClusterId = cluster_id
    request.Name = nodepool_name

    # 配置自动伸缩组
    asg_para = {
        "DesiredCapacity": desired_capacity,
        "MinSize": min_size,
        "MaxSize": max_size,
        "VpcId": vpc_id,
        "SubnetIds": subnet_ids,
        "InstanceType": instance_type,
        "InstanceChargeType": "POSTPAID_BY_HOUR",
        "SystemDisk": {
            "DiskType": "CLOUD_SSD",
            "DiskSize": 50
        },
        "DataDisks": [
            {
                "DiskType": "CLOUD_SSD",
                "DiskSize": 100
            }
        ],
        "InternetAccessible": {
            "InternetChargeType": "TRAFFIC_POSTPAID_BY_HOUR",
            "InternetMaxBandwidthOut": 10
        }
    }
    request.AutoScalingGroupPara = json.dumps(asg_para)

    # 配置标签
    labels = [
        {"Name": "node-type", "Value": "standard"},
        {"Name": "env", "Value": "production"}
    ]
    request.Labels = [models.Label(**label) for label in labels]

    # 配置操作系统
    request.NodePoolOs = "tlinux2.4(tkernel4)x86_64"
    request.OsCustomizeType = "GENERAL"

    try:
        # 创建节点池
        resp = client.CreateNodePool(request)
        nodepool_id = resp.NodePoolId

        print(f"✅ 节点池创建成功")
        print(f"   节点池 ID: {nodepool_id}")
        print(f"   请求 ID: {resp.RequestId}")

        # 等待节点池就绪
        print("\n等待节点就绪...")
        wait_for_nodes_ready(client, cluster_id, nodepool_id, desired_capacity)

        return nodepool_id

    except Exception as e:
        print(f"❌ 创建失败: {e}")
        raise


def wait_for_nodes_ready(client, cluster_id, nodepool_id, expected_count, timeout=600):
    """
    等待节点池节点就绪

    Args:
        client: TKE 客户端
        cluster_id: 集群 ID
        nodepool_id: 节点池 ID
        expected_count: 期望节点数
        timeout: 超时时间（秒）
    """
    start_time = time.time()

    while time.time() - start_time < timeout:
        try:
            # 查询节点池状态
            request = models.DescribeNodePoolRequest()
            request.ClusterId = cluster_id
            request.NodePoolIds = [nodepool_id]

            resp = client.DescribeNodePool(request)
            if resp.NodePools:
                nodepool = resp.NodePools[0]
                node_count = nodepool.NodeCountSummary.ManuallyAdded.Normal + \
                            nodepool.NodeCountSummary.AutoscalingAdded.Normal

                print(f"当前节点数: {node_count}/{expected_count}", end="\r")

                if node_count >= expected_count:
                    print(f"\n✅ 节点已就绪 ({node_count}/{expected_count})")
                    return True

            time.sleep(10)

        except Exception as e:
            print(f"\n查询状态失败: {e}")
            return False

    print(f"\n⚠️ 等待超时（{timeout}秒）")
    return False


# 使用示例
if __name__ == "__main__":
    create_nodepool(
        cluster_id="cls-abc123",
        nodepool_name="standard-nodepool",
        vpc_id="vpc-xyz789",
        subnet_ids=["subnet-abc123"],
        instance_type="S5.MEDIUM4",
        desired_capacity=3,
        min_size=1,
        max_size=10
    )