文档首页/ 云容器引擎 CCE/ API参考/ API/ 节点管理/ 创建节点

更新时间：2024-07-26 GMT+08:00

在线调试

CLI示例

查看PDF

创建节点

功能介绍

该API用于在指定集群下创建节点。

若无集群，请先创建集群。
集群管理的URL格式为：https://Endpoint/uri。其中uri为资源路径，也即API访问的路径。

接口约束

仅支持创建KVM虚拟化类型的节点，非KVM虚拟化类型的节点创建后无法正常使用。

调用方法

请参见如何调用API。

URI

POST /api/v3/projects/{project_id}/clusters/{cluster_id}/nodes

表1 路径参数
参数	是否必选	参数类型	描述
project_id	是	String	项目ID，获取方式请参见如何获取接口URI中参数。
cluster_id	是	String	集群ID，获取方式请参见如何获取接口URI中参数。

表2 Query参数
参数	是否必选	参数类型	描述
nodepoolScaleUp	否	String	标明是否为nodepool下发的请求。若不为“NodepoolScaleUp”将自动更新对应节点池的实例数

请求参数

表3 请求Header参数
参数	是否必选	参数类型	描述
Content-Type	是	String	消息体的类型（格式）
X-Auth-Token	是	String	调用接口的认证方式分为Token和AK/SK两种，如果您使用的Token方式，此参数为必填，请填写Token的值，获取方式请参见获取token。

表4 请求Body参数
参数	是否必选	参数类型	描述
kind	是	String	API类型，固定值“Node”，该值不可修改。
apiVersion	是	String	API版本，固定值“v3”，该值不可修改。
metadata	否	NodeMetadata object	metadata是节点对象的元数据定义，是集合类的元素类型，包含一组由不同名称定义的属性。
spec	是	NodeSpec object	spec是集合类的元素类型，用户对需要管理的节点对象进行详细描述的主体部分都在spec中给出。系统通过spec的描述来创建或更新对象。

表5 NodeMetadata
参数	是否必选	参数类型	描述
name	否	String	节点名称说明：命名规则：以小写字母开头，由小写字母、数字、中划线(-)、点(.)组成，长度范围1-56位，且不能以中划线(-)结尾。若name未指定或指定为空字符串，则按照默认规则生成节点名称。默认规则为：“集群名称-随机字符串”，若集群名称过长，则只取前36个字符。若节点数量(count)大于1时，则按照默认规则会在用户输入的节点名称末尾添加随机字符串。默认规则为：“用户输入名称-随机字符串”，若用户输入的节点名称长度范围超过50位时，系统截取前50位，并在末尾添加随机字符串。
uid	否	String	节点ID，资源唯一标识，创建成功后自动生成，填写无效
labels	否	Map<String,String>	CCE自有节点标签，非Kubernetes原生labels。标签可用于选择对象并查找满足某些条件的对象集合，格式为key/value键值对。示例： "labels": { "key" : "value" }
annotations	否	Map<String,String>	CCE自有节点注解，非Kubernetes原生annotations，格式为key/value键值对。示例： "annotations": { "key1" : "value1", "key2" : "value2" } 说明： Annotations不用于标识和选择对象。Annotations中的元数据可以是small或large，structured或unstructured，并且可以包括标签不允许使用的字符。仅用于查询，不支持请求时传入，填写无效。
creationTimestamp	否	String	创建时间，创建成功后自动生成，填写无效
updateTimestamp	否	String	更新时间，创建成功后自动生成，填写无效
ownerReference	否	ownerReference object	属主对象

表6 ownerReference
参数	是否必选	参数类型	描述
nodepoolName	否	String	节点池名称
nodepoolID	否	String	节点池UID

表7 NodeSpec
参数	是否必选	参数类型	描述
flavor	是	String	节点的规格，CCE支持的节点规格请参考节点规格说明获取。
az	是	String	待创建节点所在的可用区，需要指定可用区（AZ）的名称，填random选择随机可用区。 CCE支持的可用区请参考地区和终端节点。
os	否	String	节点的操作系统类型。具体支持的操作系统请参见节点操作系统说明。说明：创建节点池时，此参数为必填参数。系统会根据集群版本自动选择支持的系统版本。当前集群版本不支持该系统类型，则会报错。若在创建节点时指定了extendParam中的alpha.cce/NodeImageID参数，可以不填写此参数。创建节点池时，该参数为必选。若创建节点时使用共享磁盘空间，即磁盘初始化配置管理参数使用storage，且StorageGroups中virtualSpaces的name字段指定为share，该参数为必选。
login	是	Login object	节点的登录方式。密钥对和密码登录方式二者必选其一。
rootVolume	是	Volume object	节点的磁盘信息
dataVolumes	是	Array of Volume objects	节点的数据盘参数，磁盘挂载上限为虚拟机不超过16块，裸金属不超过10块。在此基础上还受限于虚拟机/裸金属规格可挂载磁盘数上限。（目前支持通过控制台或API为CCE节点添加第二块数据盘）。如果数据盘正供容器运行时和Kubelet组件使用，则不可被卸载，否则将导致节点不可用。针对专属云节点，参数解释与rootVolume一致
storage	否	Storage object	磁盘初始化配置管理参数。该参数配置逻辑较为复杂，详细说明请参见节点磁盘挂载。该参数缺省时，按照extendParam中的DockerLVMConfigOverride（已废弃）参数进行磁盘管理。此参数对1.15.11及以上集群版本支持。说明：如存在节点规格涉及本地盘并同时使用云硬盘场景时，请勿缺省此参数，避免出现将用户未期望的磁盘分区。说明：如希望数据盘取值范围调整至20-32768，请勿缺省此参数。说明：如希望使用共享磁盘空间(取消runtime和kubernetes分区)，请勿缺省此参数，共享磁盘空间请参考数据盘空间分配说明。
publicIP	否	NodePublicIP object	节点的弹性公网IP 说明：创建节点池添加节点时不支持该参数。
nodeNicSpec	否	NodeNicSpec object	节点的网卡信息
count	否	Integer	批量创建时节点的个数，必须为大于等于1，小于等于最大限额的正整数。作用于节点池时该项可以不填写。
billingMode	否	Integer	节点的计费模式： 0: 按需付费 1: 包周期 2: 已废弃：自动付费包周期
taints	否	Array of Taint objects	支持给创建出来的节点加Taints来设置反亲和性，taints配置不超过20条。每条Taints包含以下3个参数： Key：必须以字母或数字开头和结尾，可以包含字母、数字、连字符、下划线和点，最长63个字符；另外可以使用DNS子域作为前缀。 Value：必须以字符或数字开头，可以包含字母、数字、连字符、下划线和点，最长63个字符。 Effect：只可选NoSchedule，PreferNoSchedule或NoExecute。字段使用场景：在节点创建场景下，支持指定初始值，查询时不返回该字段；在节点池场景下，其中节点模板中支持指定初始值，查询时支持返回该字段；在其余场景下，查询时都不会返回该字段。示例： "taints": [{ "key": "status", "value": "unavailable", "effect": "NoSchedule" }, { "key": "looks", "value": "bad", "effect": "NoSchedule" }]
k8sTags	否	Map<String,String>	格式为key/value键值对。键值对个数不超过20条。 Key：必须以字母或数字开头和结尾，可以包含字母、数字、连字符、下划线和点，最长63个字符；另外可以使用DNS子域作为前缀，例如example.com/my-key，DNS子域最长253个字符。 Value：可以为空或者非空字符串，非空字符串必须以字符或数字开头，可以包含字母、数字、连字符、下划线和点，最长63个字符。字段使用场景：在节点创建场景下，支持指定初始值，查询时不返回该字段；在节点池场景下，其中节点模板中支持指定初始值，查询时支持返回该字段；在其余场景下，查询时都不会返回该字段。示例： "k8sTags": { "key": "value" }
ecsGroupId	否	String	云服务器组ID，若指定，将节点创建在该云服务器组下说明：创建节点池时该配置不会生效，若要保持节点池中的节点都在同一个云服务器组内，请在节点池 nodeManagement 字段中配置
dedicatedHostId	否	String	指定DeH主机的ID，将节点调度到自己的DeH上。说明：创建节点池添加节点时不支持该参数。
userTags	否	Array of UserTag objects	云服务器标签，键必须唯一，CCE支持的最大用户自定义标签数量依region而定，自定义标签数上限为8个。字段使用场景：在节点创建场景下，支持指定初始值，查询时不返回该字段；在节点池场景下，其中节点模板中支持指定初始值，查询时支持返回该字段；在其余场景下，查询时都不会返回该字段。说明：标签键只能包含大写字母.小写字母、数字和特殊字符(-_)以及Unicode字符，长度不超过36个字符。
runtime	否	Runtime object	容器运行时, 默认场景： 1.25以下集群：默认为"docker" 1.25及以上集群，随操作系统变化，默认的容器运行时不同：操作系统为欧拉2.5、欧拉2.8的节点默认为"docker"，其余操作系统的节点默认为"containerd"
initializedConditions	否	Array of strings	自定义初始化标记，默认值为空。 CCE节点在初始化完成之前，会打上初始化未完成污点（node.cloudprovider.kubernetes.io/uninitialized）防止pod调度到节点上。用户在创建节点时，可以通过设置initializedConditions参数，控制污点的移除时间（默认不设置超时时间）。使用示例如下：创建节点，传入参数 "initializedConditions": ["CCEInitial", "CustomedInitial"]；用户在执行完自定义初始化操作后，调用k8s接口（例如PATCH /v1/nodes/{node_ip}/status）更新节点的conditions，插入type为CCEInitial、CustomedInitial的两个标记，状态为True，如下所示： status: conditions: - type: CCEInitial status: 'True' - type: CustomedInitial status: 'True' CCE组件轮询节点的status.Conditions，查看是否存在type为CCEInitial、CustomedInitial的condition，若存在且status字段值为True，认为节点初始化完成，则移除初始化污点； initializedConditions支持设置超时时间，用户可以在创节点时传入，如："initializedConditions": ["CCEInitial:15m", "CustomedInitial:15m"]，表示超时时间为15分钟，达到超时时间后，当CCE组件轮询到节点时会自动忽略初始化condition，移除初始化污点。必须以字母、数字组成，长度范围1-20位。标记数量不超过2个。超时时间仅支持分钟(m)单位。
extendParam	否	NodeExtendParam object	创建节点时的扩展参数。
hostnameConfig	否	HostnameConfig object	K8S节点名称配置参数，支持的集群版本为v1.23.6-r0到v1.25或者v1.25.2-r0及以上。
serverEnterpriseProjectID	否	String	服务器企业项目ID。CCE服务不实现EPS相关特性，该字段仅用于同步服务器企业项目ID。创建节点/节点池场景：可指定已存在企业项目，当取值为空时，该字段继承集群企业项目属性。更新节点池场景：配置修改后仅会对新增节点的服务器生效，存量节点需前往EPS界面迁移。如果更新时不指定值，不会更新该字段。当该字段为空时，返回集群企业项目。

表8 Login
参数	是否必选	参数类型	描述
sshKey	否	String	选择密钥对方式登录时的密钥对名称。
userPassword	否	UserPassword object	选择密码方式登录时的账号密码信息，之后可通过此账号密码登录节点。

表9 UserPassword
参数	是否必选	参数类型	描述
username	否	String	登录账号，默认为“root”
password	是	String	登录密码，若创建节点通过用户名密码方式，即使用该字段，则响应体中该字段作屏蔽展示。密码复杂度要求：长度为8-26位。密码至少必须包含大写字母、小写字母、数字和特殊字符（!@$%^-_=+[{}]:,./?）中的三种。密码不能包含用户名或用户名的逆序。创建节点时password字段需要加盐加密，具体方法请参见创建节点时password字段加盐加密。

**表10** Volume
参数	是否必选	参数类型	描述
size	是	Integer	磁盘大小，单位为GB 系统盘取值范围：40~1024 第一块数据盘取值范围：20~32768(当缺省磁盘初始化配置管理参数storage时，数据盘取值范围：100-32768) 其他数据盘取值范围：10~32768(当缺省磁盘初始化配置管理参数storage时，数据盘取值范围：100-32768)
volumetype	是	String	磁盘类型，取值请参见创建云服务器中“root_volume字段数据结构说明”。 SAS：高IO，是指由SAS存储提供资源的磁盘类型。 SSD：超高IO，是指由SSD存储提供资源的磁盘类型。 SATA：普通IO，是指由SATA存储提供资源的磁盘类型。EVS已下线SATA磁盘，仅存量节点有此类型的磁盘。
extendParam	否	Map<String,Object>	磁盘扩展参数，取值请参见创建云服务器中“extendparam”参数的描述。链接请参见创建云服务器。
cluster_id	否	String	云服务器系统盘对应的存储池的ID。仅用作专属云集群，专属分布式存储DSS的存储池ID，即dssPoolID。获取方法请参见获取单个专属分布式存储池详情中“表3 响应参数”的ID字段。
cluster_type	否	String	云服务器系统盘对应的磁盘存储类型。仅用作专属云集群，固定取值为dss。
hw:passthrough	否	Boolean	使用SDI规格创建虚拟机时请关注该参数，如果该参数值为true，说明创建的为SCSI类型的卷节点池类型为ElasticBMS时，此参数必须填写为true 如存在节点规格涉及本地盘并同时使用云硬盘场景时，请设置磁盘初始化配置管理参数，参见节点磁盘挂载。
metadata	否	VolumeMetadata object	云硬盘加密信息，仅在创建节点系统盘或数据盘需加密时须填写。

**表11** VolumeMetadata
参数	是否必选	参数类型	描述
__system__encrypted	否	String	表示云硬盘加密功能的字段，'0'代表不加密，'1'代表加密。该字段不存在时，云硬盘默认为不加密。
__system__cmkid	否	String	用户主密钥ID，是metadata中的表示加密功能的字段，与__system__encrypted配合使用。

**表12** Storage
参数	是否必选	参数类型	描述
storageSelectors	是	Array of StorageSelectors objects	磁盘选择，根据matchLabels和storageType对匹配的磁盘进行管理。磁盘匹配存在先后顺序，靠前的匹配规则优先匹配。
storageGroups	是	Array of StorageGroups objects	由多个存储设备组成的存储组，用于各个存储空间的划分。

**表13** StorageSelectors
参数	是否必选	参数类型	描述
name	是	String	selector的名字，作为storageGroup中selectorNames的索引，因此各个selector间的名字不能重复。
storageType	是	String	存储类型，当前仅支持evs（云硬盘）或local（本地盘）；local存储类型不支持磁盘选择，所有本地盘将被组成一个VG，因此也仅允许只有一个local类型的storageSelector。
matchLabels	否	matchLabels object	evs盘的匹配字段，支持DataVolume中的size、volumeType、metadataEncrypted、metadataCmkid、count五个字段。

**表14** matchLabels
参数	是否必选	参数类型	描述
size	否	String	匹配的磁盘大小，不填则无磁盘大小限制。例如：100.
volumeType	否	String	云硬盘类型，目前支持SSD\GPSSD\SAS\ESSD\SATA等，不填则无云硬盘类型限制。
metadataEncrypted	否	String	磁盘加密标识符，0代表不加密，1代表加密，不填则无磁盘加密标识符限制。
metadataCmkid	否	String	加密磁盘的用户主密钥ID，长度为36字节的字符串，不填则无磁盘密钥ID限制。
count	否	String	磁盘选择个数，不填则选择所有此类磁盘。

**表15** StorageGroups
参数	是否必选	参数类型	描述
name	是	String	storageGroups的名字，作为虚拟存储组的名字，因此各个group名字不能重复。说明：当cceManaged=true时，name必须为：vgpaas。当数据盘作为临时存储卷时：name必须为：vg-everest-localvolume-ephemeral。当数据盘作为持久存储卷时：name必须为：vg-everest-localvolume-persistent。
cceManaged	否	Boolean	k8s及runtime所属存储空间。有且仅有一个group被设置为true，不填默认false。
selectorNames	是	Array of strings	对应storageSelectors中的name，一个group可选择多个selector；但一个selector只能被一个group选择。
virtualSpaces	是	Array of VirtualSpace objects	group中空间配置的详细管理。

**表16** VirtualSpace
参数	是否必选	参数类型	描述
name	是	String	virtualSpace的名称，当前仅支持四种类型：share、kubernetes、runtime、user。 share：共享磁盘空间配置(取消runtime和kubernetes分区)，需配置lvmConfig； kubernetes：k8s空间配置，需配置lvmConfig； runtime：运行时空间配置，需配置runtimeConfig； user：用户空间配置，需配置lvmConfig
size	是	String	virtualSpace的大小，仅支持整数百分比。例如：90%。说明：一个group中所有virtualSpace的百分比之和不得超过100%
lvmConfig	否	LVMConfig object	lvm配置管理，适用于share、kubernetes和user空间配置。需要注意：一个virtualSpace仅支持一个config配置。
runtimeConfig	否	RuntimeConfig object	runtime配置管理，适用于运行时空间配置。需要注意：一个virtualSpace仅支持一个config配置。

**表17** LVMConfig
参数	是否必选	参数类型	描述
lvType	是	String	LVM写入模式：linear、striped。linear：线性模式；striped：条带模式，使用多块磁盘组成条带模式，能够提升磁盘性能。
path	否	String	磁盘挂载路径。仅在用户配置中生效。支持包含：数字、大小写字母、点、中划线、下划线的绝对路径。

**表18** RuntimeConfig
参数	是否必选	参数类型	描述
lvType	是	String	LVM写入模式：linear、striped。linear：线性模式；striped：条带模式，使用多块磁盘组成条带模式，能够提升磁盘性能。

**表19** NodePublicIP
参数	是否必选	参数类型	描述
ids	否	Array of strings	已有的弹性IP的ID列表。数量不得大于待创建节点数说明：若已配置ids参数，则无需配置count和eip参数
count	否	Integer	要动态创建的弹性IP个数。说明： count参数与eip参数必须同时配置。
eip	否	NodeEIPSpec object	弹性IP参数说明：创建节点池时不支持此参数

**表20** NodeEIPSpec
参数	是否必选	参数类型	描述
iptype	是	String	弹性IP类型，取值请参见申请EIP接口中publicip.type说明。链接请参见申请EIP。
bandwidth	否	NodeBandwidth object	弹性IP的带宽参数

**表21** NodeBandwidth
参数	是否必选	参数类型	描述
chargemode	否	String	带宽的计费类型：未传该字段，表示按带宽计费。字段值为空，表示按带宽计费。字段值为“traffic”，表示按流量计费。字段为其它值，会导致创建云服务器失败。说明：按带宽计费：按公网传输速率（单位为Mbps）计费。当您的带宽利用率高于10%时，建议优先选择按带宽计费。按流量计费：只允许在创建按需节点时指定，按公网传输的数据总量（单位为GB）计费。当您的带宽利用率低于10%时，建议优先选择按流量计费。
size	否	Integer	带宽大小，取值请参见取值请参见申请EIP接口中bandwidth.size说明。链接请参见申请EIP。
sharetype	否	String	带宽的共享类型，共享类型枚举：PER，表示独享，目前仅支持独享。

**表22** NodeNicSpec
参数	是否必选	参数类型	描述
primaryNic	否	NicSpec object	主网卡的描述信息。
extNics	否	Array of NicSpec objects	扩展网卡说明：创建节点池添加节点时不支持该参数。

**表23** NicSpec
参数	是否必选	参数类型	描述
subnetId	否	String	网卡所在子网的网络ID。主网卡创建时若未指定subnetId,将使用集群子网。扩展网卡创建时必须指定subnetId。
fixedIps	否	Array of strings	主网卡的IP将通过fixedIps指定，数量不得大于创建的节点数。fixedIps或ipBlock同时只能指定一个。扩展网卡不支持指定fiexdIps。
ipBlock	否	String	主网卡的IP段的CIDR格式，创建的节点IP将属于该IP段内。fixedIps或ipBlock同时只能指定一个。

**表24** Taint
参数	是否必选	参数类型	描述
key	是	String	键
value	否	String	值
effect	是	String	作用效果

**表25** UserTag
参数	是否必选	参数类型	描述
key	否	String	云服务器标签的键。不得以"CCE-"或"__type_baremetal"开头
value	否	String	云服务器标签的值

**表26** Runtime
参数	是否必选	参数类型	描述
name	否	String	容器运行时，默认场景： v1.25以下集群：默认为"docker" v1.25及以上集群，随操作系统变化，默认的容器运行时不同：操作系统为EulerOS 2.5、EulerOS 2.8的节点默认为"docker"，其余操作系统的节点默认为"containerd"

**表27** NodeExtendParam
参数	是否必选	参数类型	描述
ecs:performancetype	否	String	云服务器规格的分类。响应中会返回此字段。
orderID	否	String	订单ID，节点付费类型为自动付费包周期类型时，响应中会返回此字段(仅创建场景涉及)。
productID	否	String	产品ID，节点付费类型为自动付费包周期类型时，响应中会返回此字段。
maxPods	否	Integer	节点最大允许创建的实例数(Pod)，该数量包含系统默认实例，取值范围为16~256。该设置的目的为防止节点因管理过多实例而负载过重，请根据您的业务需要进行设置。节点可以创建多少个Pod，受多个参数影响，具体请参见节点可创建的最大Pod数量说明。
periodType	否	String	month：月 year：年说明：作为请求参数，billingMode为1（包周期）或2（已废弃：自动付费包周期）时生效，且为必选。作为响应参数，仅在创建包周期节点时返回。
periodNum	否	Integer	订购周期数，取值范围： periodType=month（周期类型为月）时，取值为[1-9]。 periodType=year（周期类型为年）时，取值为[1-3]。说明：作为请求参数，billingMode为1或2（已废弃）时生效，且为必选。作为响应参数，仅在创建包周期节点时返回。
isAutoRenew	否	String	是否自动续订 “true”：自动续订 “false”：不自动续订说明： billingMode为1或2（已废弃）时生效，不填写此参数时默认不会自动续费。
isAutoPay	否	String	是否自动扣款 “true”：自动扣款 “false”：不自动扣款说明： billingMode为1或2（已废弃）时生效，billingMode为1时不填写此参数时默认不会自动扣款。（已废弃：billingMode为2时不填写此参数时默认会自动扣款）
DockerLVMConfigOverride	否	String	Docker数据盘配置项（已废弃，请使用storage字段）。默认配置示例如下： "DockerLVMConfigOverride":"dockerThinpool=vgpaas/90%VG;kubernetesLV=vgpaas/10%VG;diskType=evs;lvType=linear" 默认配置在无VD类型磁盘时，会由于数据盘查找失败而出错，请根据真实盘符类型填写diskType。包含如下字段： userLV（可选）：用户空间的大小，示例格式：vgpaas/20%VG userPath（可选）：用户空间挂载路径，示例格式：/home/wqt-test diskType：磁盘类型，目前只有evs、hdd和ssd三种格式 lvType：逻辑卷的类型，目前支持linear和striped两种，示例格式：striped dockerThinpool：Docker盘的空间大小，示例格式：vgpaas/60%VG kubernetesLV：Kubelet空间大小，示例格式：vgpaas/20%VG
dockerBaseSize	否	Integer	节点上单容器的可用磁盘空间大小（已废弃，请优先使用containerBaseSize参数），单位G。不配置该值或值为0时将使用默认值，Devicemapper模式下默认值为10；OverlayFS模式默认不限制单容器可用空间大小，且dockerBaseSize设置仅在新版本集群的EulerOS/HCEOS2.0节点上生效。 CCE节点容器运行时空间配置请参考数据盘空间分配说明。 Devicemapper模式下建议dockerBaseSize配置不超过80G，设置过大时可能会导致容器运行时初始化时间过长而启动失败，若对容器磁盘大小有特殊要求，可考虑使用挂载外部或本地存储方式代替。
containerBaseSize	否	Integer	节点上单容器的可用磁盘空间大小，单位G。不配置该值或值为0时将使用默认值，OverlayFS模式默认不限制单容器可用空间大小；Devicemapper模式下默认值为10，且containerBaseSize设置仅在新版本集群（v1.23.14-r0/v1.25.9-r0/v1.27.6-r0/v1.28.4-r0及以上）的EulerOS/HCEOS2.0节点上生效。 CCE节点容器运行时空间配置请参考数据盘空间分配说明。 Devicemapper模式下建议containerBaseSize配置不超过80G，设置过大时可能会导致容器运行时初始化时间过长而启动失败，若对容器磁盘大小有特殊要求，可考虑使用挂载外部或本地存储方式代替；Devicemapper模式在新版中仅有共池裸机使用，已逐步废弃。
publicKey	否	String	节点的公钥。
alpha.cce/preInstall	否	String	安装前执行脚本。说明：输入的值需要经过Base64编码，方法如下： echo -n "待编码内容" \| base64
alpha.cce/postInstall	否	String	安装后执行脚本。说明：输入的值需要经过Base64编码，方法如下： echo -n "待编码内容" \| base64
alpha.cce/NodeImageID	否	String	如果创建裸金属节点，需要使用自定义镜像时用此参数。
nicMultiqueue	否	String	弹性网卡队列数配置，默认配置示例如下： "[{\"queue\":4}]" 包含如下字段： queue: 弹性网卡队列数。仅在turbo集群的BMS节点时，该字段才可配置。当前支持可配置队列数以及弹性网卡数：{"1":128, "2":92, "4":92, "8":32, "16":16,"28":9}, 既1弹性网卡队列可绑定128张弹性网卡，2队列弹性网卡可绑定92张，以此类推。弹性网卡队列数越多，性能越强，但可绑定弹性网卡数越少，请根据您的需求进行配置（创建后不可修改）。
nicThreshold	否	String	弹性网卡预绑定比例配置，默认配置示例如下： "0.3:0.6" 第一位小数：预绑定低水位，弹性网卡预绑定的最低比例（最小预绑定弹性网卡数 = ⌊节点的总弹性网卡数 * 预绑定低水位⌋）第二位小数：预绑定高水位，弹性网卡预绑定的最高比例（最大预绑定弹性网卡数 = ⌊节点的总弹性网卡数 * 预绑定高水位⌋） BMS节点上绑定的弹性网卡数：Pod正在使用的弹性网卡数 + 最小预绑定弹性网卡数 < BMS节点上绑定的弹性网卡数 < Pod正在使用的弹性网卡数 + 最大预绑定弹性网卡数 BMS节点上当预绑定弹性网卡数 < 最小预绑定弹性网卡数时：会绑定弹性网卡，使得预绑定弹性网卡数 = 最小预绑定弹性网卡数 BMS节点上当预绑定弹性网卡数 > 最大预绑定弹性网卡数时：会定时解绑弹性网卡（约2分钟一次），直到预绑定弹性网卡数 = 最大预绑定弹性网卡数取值范围：[0.0, 1.0]; 一位小数; 低水位 <= 高水位仅在turbo集群的BMS节点时，该字段才可配置。弹性网卡预绑定能加快工作负载的创建，但会占用IP，请根据您的需求进行配置。
chargingMode	否	Integer	节点的计费模式。已废弃，请使用NodeSpec中的billingMode字段。
marketType	否	String	创建竞价实例时，需指定该参数的值为“spot”。说明：仅当billingMode=0时此参数生效
spotPrice	否	String	用户愿意为竞价实例每小时支付的最高价格。说明：仅当billingMode=0且marketType=spot时，该参数设置后生效。当billingMode=0且marketType=spot时，如果不传递spotPrice，默认使用按需购买的价格作为竞价。 spotPrice需要小于等于按需价格并大于等于云服务器市场价格。
agency_name	否	String	委托的名称。委托是由租户管理员在统一身份认证服务（Identity and Access Management，IAM）上创建的，可以为CCE节点提供访问云服务器的临时凭证。作为响应参数仅在创建节点传入时返回该字段。
kubeReservedMem	否	Integer	节点内存预留，Kubernetes相关组件预留值。
systemReservedMem	否	Integer	节点内存预留，系统组件预留值。
init-node-password	否	String	节点密码，作为响应参数时，固定展示星号。

**表28** HostnameConfig
参数	是否必选	参数类型	描述
type	是	String	K8S节点名称配置类型, 默认为“privateIp”。 privateIp: 将节点私有IP作为K8S节点名称 cceNodeName: 将CCE节点名称作为K8S节点名称说明：配置为cceNodeName的节点, 其节点名称、K8S节点名称以及虚机名称相同。节点名称不支持修改, 并且在ECS侧修改了虚机名称，同步云服务器时，不会将修改后的虚机名称同步到节点。配置为cceNodeName的节点，为了避免K8S节点名称冲突，系统会自动在节点名称后添加后缀，后缀的格式为中划线(-)+五位随机字符，随机字符的取值为[a-z0-9]。

响应参数

状态码： 201

**表29** 响应Body参数
参数	参数类型	描述
kind	String	API类型，固定值“Node”，该值不可修改。
apiVersion	String	API版本，固定值“v3”，该值不可修改。
metadata	NodeMetadata object	metadata是节点对象的元数据定义，是集合类的元素类型，包含一组由不同名称定义的属性。
spec	NodeSpec object	spec是集合类的元素类型，用户对需要管理的节点对象进行详细描述的主体部分都在spec中给出。系统通过spec的描述来创建或更新对象。
status	NodeStatus object	节点状态，动态记录，创建或修改时指定无意义.

**表30** NodeMetadata
参数	参数类型	描述
name	String	节点名称说明：命名规则：以小写字母开头，由小写字母、数字、中划线(-)、点(.)组成，长度范围1-56位，且不能以中划线(-)结尾。若name未指定或指定为空字符串，则按照默认规则生成节点名称。默认规则为：“集群名称-随机字符串”，若集群名称过长，则只取前36个字符。若节点数量(count)大于1时，则按照默认规则会在用户输入的节点名称末尾添加随机字符串。默认规则为：“用户输入名称-随机字符串”，若用户输入的节点名称长度范围超过50位时，系统截取前50位，并在末尾添加随机字符串。
uid	String	节点ID，资源唯一标识，创建成功后自动生成，填写无效
labels	Map<String,String>	CCE自有节点标签，非Kubernetes原生labels。标签可用于选择对象并查找满足某些条件的对象集合，格式为key/value键值对。示例： "labels": { "key" : "value" }
annotations	Map<String,String>	CCE自有节点注解，非Kubernetes原生annotations，格式为key/value键值对。示例： "annotations": { "key1" : "value1", "key2" : "value2" } 说明： Annotations不用于标识和选择对象。Annotations中的元数据可以是small或large，structured或unstructured，并且可以包括标签不允许使用的字符。仅用于查询，不支持请求时传入，填写无效。
creationTimestamp	String	创建时间，创建成功后自动生成，填写无效
updateTimestamp	String	更新时间，创建成功后自动生成，填写无效
ownerReference	ownerReference object	属主对象

**表31** ownerReference
参数	参数类型	描述
nodepoolName	String	节点池名称
nodepoolID	String	节点池UID

**表32** NodeSpec
参数	参数类型	描述
flavor	String	节点的规格，CCE支持的节点规格请参考节点规格说明获取。
az	String	待创建节点所在的可用区，需要指定可用区（AZ）的名称，填random选择随机可用区。 CCE支持的可用区请参考地区和终端节点。
os	String	节点的操作系统类型。具体支持的操作系统请参见节点操作系统说明。说明：创建节点池时，此参数为必填参数。系统会根据集群版本自动选择支持的系统版本。当前集群版本不支持该系统类型，则会报错。若在创建节点时指定了extendParam中的alpha.cce/NodeImageID参数，可以不填写此参数。创建节点池时，该参数为必选。若创建节点时使用共享磁盘空间，即磁盘初始化配置管理参数使用storage，且StorageGroups中virtualSpaces的name字段指定为share，该参数为必选。
login	Login object	节点的登录方式。密钥对和密码登录方式二者必选其一。
rootVolume	Volume object	节点的磁盘信息
dataVolumes	Array of Volume objects	节点的数据盘参数，磁盘挂载上限为虚拟机不超过16块，裸金属不超过10块。在此基础上还受限于虚拟机/裸金属规格可挂载磁盘数上限。（目前支持通过控制台或API为CCE节点添加第二块数据盘）。如果数据盘正供容器运行时和Kubelet组件使用，则不可被卸载，否则将导致节点不可用。针对专属云节点，参数解释与rootVolume一致
storage	Storage object	磁盘初始化配置管理参数。该参数配置逻辑较为复杂，详细说明请参见节点磁盘挂载。该参数缺省时，按照extendParam中的DockerLVMConfigOverride（已废弃）参数进行磁盘管理。此参数对1.15.11及以上集群版本支持。说明：如存在节点规格涉及本地盘并同时使用云硬盘场景时，请勿缺省此参数，避免出现将用户未期望的磁盘分区。说明：如希望数据盘取值范围调整至20-32768，请勿缺省此参数。说明：如希望使用共享磁盘空间(取消runtime和kubernetes分区)，请勿缺省此参数，共享磁盘空间请参考数据盘空间分配说明。
publicIP	NodePublicIP object	节点的弹性公网IP 说明：创建节点池添加节点时不支持该参数。
nodeNicSpec	NodeNicSpec object	节点的网卡信息
count	Integer	批量创建时节点的个数，必须为大于等于1，小于等于最大限额的正整数。作用于节点池时该项可以不填写。
billingMode	Integer	节点的计费模式： 0: 按需付费 1: 包周期 2: 已废弃：自动付费包周期
taints	Array of Taint objects	支持给创建出来的节点加Taints来设置反亲和性，taints配置不超过20条。每条Taints包含以下3个参数： Key：必须以字母或数字开头和结尾，可以包含字母、数字、连字符、下划线和点，最长63个字符；另外可以使用DNS子域作为前缀。 Value：必须以字符或数字开头，可以包含字母、数字、连字符、下划线和点，最长63个字符。 Effect：只可选NoSchedule，PreferNoSchedule或NoExecute。字段使用场景：在节点创建场景下，支持指定初始值，查询时不返回该字段；在节点池场景下，其中节点模板中支持指定初始值，查询时支持返回该字段；在其余场景下，查询时都不会返回该字段。示例： "taints": [{ "key": "status", "value": "unavailable", "effect": "NoSchedule" }, { "key": "looks", "value": "bad", "effect": "NoSchedule" }]
k8sTags	Map<String,String>	格式为key/value键值对。键值对个数不超过20条。 Key：必须以字母或数字开头和结尾，可以包含字母、数字、连字符、下划线和点，最长63个字符；另外可以使用DNS子域作为前缀，例如example.com/my-key，DNS子域最长253个字符。 Value：可以为空或者非空字符串，非空字符串必须以字符或数字开头，可以包含字母、数字、连字符、下划线和点，最长63个字符。字段使用场景：在节点创建场景下，支持指定初始值，查询时不返回该字段；在节点池场景下，其中节点模板中支持指定初始值，查询时支持返回该字段；在其余场景下，查询时都不会返回该字段。示例： "k8sTags": { "key": "value" }
ecsGroupId	String	云服务器组ID，若指定，将节点创建在该云服务器组下说明：创建节点池时该配置不会生效，若要保持节点池中的节点都在同一个云服务器组内，请在节点池 nodeManagement 字段中配置
dedicatedHostId	String	指定DeH主机的ID，将节点调度到自己的DeH上。说明：创建节点池添加节点时不支持该参数。
userTags	Array of UserTag objects	云服务器标签，键必须唯一，CCE支持的最大用户自定义标签数量依region而定，自定义标签数上限为8个。字段使用场景：在节点创建场景下，支持指定初始值，查询时不返回该字段；在节点池场景下，其中节点模板中支持指定初始值，查询时支持返回该字段；在其余场景下，查询时都不会返回该字段。说明：标签键只能包含大写字母.小写字母、数字和特殊字符(-_)以及Unicode字符，长度不超过36个字符。
runtime	Runtime object	容器运行时, 默认场景： 1.25以下集群：默认为"docker" 1.25及以上集群，随操作系统变化，默认的容器运行时不同：操作系统为欧拉2.5、欧拉2.8的节点默认为"docker"，其余操作系统的节点默认为"containerd"
initializedConditions	Array of strings	自定义初始化标记，默认值为空。 CCE节点在初始化完成之前，会打上初始化未完成污点（node.cloudprovider.kubernetes.io/uninitialized）防止pod调度到节点上。用户在创建节点时，可以通过设置initializedConditions参数，控制污点的移除时间（默认不设置超时时间）。使用示例如下：创建节点，传入参数 "initializedConditions": ["CCEInitial", "CustomedInitial"]；用户在执行完自定义初始化操作后，调用k8s接口（例如PATCH /v1/nodes/{node_ip}/status）更新节点的conditions，插入type为CCEInitial、CustomedInitial的两个标记，状态为True，如下所示： status: conditions: - type: CCEInitial status: 'True' - type: CustomedInitial status: 'True' CCE组件轮询节点的status.Conditions，查看是否存在type为CCEInitial、CustomedInitial的condition，若存在且status字段值为True，认为节点初始化完成，则移除初始化污点； initializedConditions支持设置超时时间，用户可以在创节点时传入，如："initializedConditions": ["CCEInitial:15m", "CustomedInitial:15m"]，表示超时时间为15分钟，达到超时时间后，当CCE组件轮询到节点时会自动忽略初始化condition，移除初始化污点。必须以字母、数字组成，长度范围1-20位。标记数量不超过2个。超时时间仅支持分钟(m)单位。
extendParam	NodeExtendParam object	创建节点时的扩展参数。
hostnameConfig	HostnameConfig object	K8S节点名称配置参数，支持的集群版本为v1.23.6-r0到v1.25或者v1.25.2-r0及以上。
serverEnterpriseProjectID	String	服务器企业项目ID。CCE服务不实现EPS相关特性，该字段仅用于同步服务器企业项目ID。创建节点/节点池场景：可指定已存在企业项目，当取值为空时，该字段继承集群企业项目属性。更新节点池场景：配置修改后仅会对新增节点的服务器生效，存量节点需前往EPS界面迁移。如果更新时不指定值，不会更新该字段。当该字段为空时，返回集群企业项目。

**表33** Login
参数	参数类型	描述
sshKey	String	选择密钥对方式登录时的密钥对名称。
userPassword	UserPassword object	选择密码方式登录时的账号密码信息，之后可通过此账号密码登录节点。

**表34** UserPassword
参数	参数类型	描述
username	String	登录账号，默认为“root”
password	String	登录密码，若创建节点通过用户名密码方式，即使用该字段，则响应体中该字段作屏蔽展示。密码复杂度要求：长度为8-26位。密码至少必须包含大写字母、小写字母、数字和特殊字符（!@$%^-_=+[{}]:,./?）中的三种。密码不能包含用户名或用户名的逆序。创建节点时password字段需要加盐加密，具体方法请参见创建节点时password字段加盐加密。

**表35** Volume
参数	参数类型	描述
size	Integer	磁盘大小，单位为GB 系统盘取值范围：40~1024 第一块数据盘取值范围：20~32768(当缺省磁盘初始化配置管理参数storage时，数据盘取值范围：100-32768) 其他数据盘取值范围：10~32768(当缺省磁盘初始化配置管理参数storage时，数据盘取值范围：100-32768)
volumetype	String	磁盘类型，取值请参见创建云服务器中“root_volume字段数据结构说明”。 SAS：高IO，是指由SAS存储提供资源的磁盘类型。 SSD：超高IO，是指由SSD存储提供资源的磁盘类型。 SATA：普通IO，是指由SATA存储提供资源的磁盘类型。EVS已下线SATA磁盘，仅存量节点有此类型的磁盘。
extendParam	Map<String,Object>	磁盘扩展参数，取值请参见创建云服务器中“extendparam”参数的描述。链接请参见创建云服务器。
cluster_id	String	云服务器系统盘对应的存储池的ID。仅用作专属云集群，专属分布式存储DSS的存储池ID，即dssPoolID。获取方法请参见获取单个专属分布式存储池详情中“表3 响应参数”的ID字段。
cluster_type	String	云服务器系统盘对应的磁盘存储类型。仅用作专属云集群，固定取值为dss。
hw:passthrough	Boolean	使用SDI规格创建虚拟机时请关注该参数，如果该参数值为true，说明创建的为SCSI类型的卷节点池类型为ElasticBMS时，此参数必须填写为true 如存在节点规格涉及本地盘并同时使用云硬盘场景时，请设置磁盘初始化配置管理参数，参见节点磁盘挂载。
metadata	VolumeMetadata object	云硬盘加密信息，仅在创建节点系统盘或数据盘需加密时须填写。

**表36** VolumeMetadata
参数	参数类型	描述
__system__encrypted	String	表示云硬盘加密功能的字段，'0'代表不加密，'1'代表加密。该字段不存在时，云硬盘默认为不加密。
__system__cmkid	String	用户主密钥ID，是metadata中的表示加密功能的字段，与__system__encrypted配合使用。

**表37** Storage
参数	参数类型	描述
storageSelectors	Array of StorageSelectors objects	磁盘选择，根据matchLabels和storageType对匹配的磁盘进行管理。磁盘匹配存在先后顺序，靠前的匹配规则优先匹配。
storageGroups	Array of StorageGroups objects	由多个存储设备组成的存储组，用于各个存储空间的划分。

**表38** StorageSelectors
参数	参数类型	描述
name	String	selector的名字，作为storageGroup中selectorNames的索引，因此各个selector间的名字不能重复。
storageType	String	存储类型，当前仅支持evs（云硬盘）或local（本地盘）；local存储类型不支持磁盘选择，所有本地盘将被组成一个VG，因此也仅允许只有一个local类型的storageSelector。
matchLabels	matchLabels object	evs盘的匹配字段，支持DataVolume中的size、volumeType、metadataEncrypted、metadataCmkid、count五个字段。

**表39** matchLabels
参数	参数类型	描述
size	String	匹配的磁盘大小，不填则无磁盘大小限制。例如：100.
volumeType	String	云硬盘类型，目前支持SSD\GPSSD\SAS\ESSD\SATA等，不填则无云硬盘类型限制。
metadataEncrypted	String	磁盘加密标识符，0代表不加密，1代表加密，不填则无磁盘加密标识符限制。
metadataCmkid	String	加密磁盘的用户主密钥ID，长度为36字节的字符串，不填则无磁盘密钥ID限制。
count	String	磁盘选择个数，不填则选择所有此类磁盘。

**表40** StorageGroups
参数	参数类型	描述
name	String	storageGroups的名字，作为虚拟存储组的名字，因此各个group名字不能重复。说明：当cceManaged=true时，name必须为：vgpaas。当数据盘作为临时存储卷时：name必须为：vg-everest-localvolume-ephemeral。当数据盘作为持久存储卷时：name必须为：vg-everest-localvolume-persistent。
cceManaged	Boolean	k8s及runtime所属存储空间。有且仅有一个group被设置为true，不填默认false。
selectorNames	Array of strings	对应storageSelectors中的name，一个group可选择多个selector；但一个selector只能被一个group选择。
virtualSpaces	Array of VirtualSpace objects	group中空间配置的详细管理。

**表41** VirtualSpace
参数	参数类型	描述
name	String	virtualSpace的名称，当前仅支持四种类型：share、kubernetes、runtime、user。 share：共享磁盘空间配置(取消runtime和kubernetes分区)，需配置lvmConfig； kubernetes：k8s空间配置，需配置lvmConfig； runtime：运行时空间配置，需配置runtimeConfig； user：用户空间配置，需配置lvmConfig
size	String	virtualSpace的大小，仅支持整数百分比。例如：90%。说明：一个group中所有virtualSpace的百分比之和不得超过100%
lvmConfig	LVMConfig object	lvm配置管理，适用于share、kubernetes和user空间配置。需要注意：一个virtualSpace仅支持一个config配置。
runtimeConfig	RuntimeConfig object	runtime配置管理，适用于运行时空间配置。需要注意：一个virtualSpace仅支持一个config配置。

**表42** LVMConfig
参数	参数类型	描述
lvType	String	LVM写入模式：linear、striped。linear：线性模式；striped：条带模式，使用多块磁盘组成条带模式，能够提升磁盘性能。
path	String	磁盘挂载路径。仅在用户配置中生效。支持包含：数字、大小写字母、点、中划线、下划线的绝对路径。

**表43** RuntimeConfig
参数	参数类型	描述
lvType	String	LVM写入模式：linear、striped。linear：线性模式；striped：条带模式，使用多块磁盘组成条带模式，能够提升磁盘性能。

**表44** NodePublicIP
参数	参数类型	描述
ids	Array of strings	已有的弹性IP的ID列表。数量不得大于待创建节点数说明：若已配置ids参数，则无需配置count和eip参数
count	Integer	要动态创建的弹性IP个数。说明： count参数与eip参数必须同时配置。
eip	NodeEIPSpec object	弹性IP参数说明：创建节点池时不支持此参数

**表45** NodeEIPSpec
参数	参数类型	描述
iptype	String	弹性IP类型，取值请参见申请EIP接口中publicip.type说明。链接请参见申请EIP。
bandwidth	NodeBandwidth object	弹性IP的带宽参数

**表46** NodeBandwidth
参数	参数类型	描述
chargemode	String	带宽的计费类型：未传该字段，表示按带宽计费。字段值为空，表示按带宽计费。字段值为“traffic”，表示按流量计费。字段为其它值，会导致创建云服务器失败。说明：按带宽计费：按公网传输速率（单位为Mbps）计费。当您的带宽利用率高于10%时，建议优先选择按带宽计费。按流量计费：只允许在创建按需节点时指定，按公网传输的数据总量（单位为GB）计费。当您的带宽利用率低于10%时，建议优先选择按流量计费。
size	Integer	带宽大小，取值请参见取值请参见申请EIP接口中bandwidth.size说明。链接请参见申请EIP。
sharetype	String	带宽的共享类型，共享类型枚举：PER，表示独享，目前仅支持独享。

**表47** NodeNicSpec
参数	参数类型	描述
primaryNic	NicSpec object	主网卡的描述信息。
extNics	Array of NicSpec objects	扩展网卡说明：创建节点池添加节点时不支持该参数。

**表48** NicSpec
参数	参数类型	描述
subnetId	String	网卡所在子网的网络ID。主网卡创建时若未指定subnetId,将使用集群子网。扩展网卡创建时必须指定subnetId。
fixedIps	Array of strings	主网卡的IP将通过fixedIps指定，数量不得大于创建的节点数。fixedIps或ipBlock同时只能指定一个。扩展网卡不支持指定fiexdIps。
ipBlock	String	主网卡的IP段的CIDR格式，创建的节点IP将属于该IP段内。fixedIps或ipBlock同时只能指定一个。

**表49** Taint
参数	参数类型	描述
key	String	键
value	String	值
effect	String	作用效果

**表50** UserTag
参数	参数类型	描述
key	String	云服务器标签的键。不得以"CCE-"或"__type_baremetal"开头
value	String	云服务器标签的值

**表51** Runtime
参数	参数类型	描述
name	String	容器运行时，默认场景： v1.25以下集群：默认为"docker" v1.25及以上集群，随操作系统变化，默认的容器运行时不同：操作系统为EulerOS 2.5、EulerOS 2.8的节点默认为"docker"，其余操作系统的节点默认为"containerd"

**表52** NodeExtendParam
参数	参数类型	描述
ecs:performancetype	String	云服务器规格的分类。响应中会返回此字段。
orderID	String	订单ID，节点付费类型为自动付费包周期类型时，响应中会返回此字段(仅创建场景涉及)。
productID	String	产品ID，节点付费类型为自动付费包周期类型时，响应中会返回此字段。
maxPods	Integer	节点最大允许创建的实例数(Pod)，该数量包含系统默认实例，取值范围为16~256。该设置的目的为防止节点因管理过多实例而负载过重，请根据您的业务需要进行设置。节点可以创建多少个Pod，受多个参数影响，具体请参见节点可创建的最大Pod数量说明。
periodType	String	month：月 year：年说明：作为请求参数，billingMode为1（包周期）或2（已废弃：自动付费包周期）时生效，且为必选。作为响应参数，仅在创建包周期节点时返回。
periodNum	Integer	订购周期数，取值范围： periodType=month（周期类型为月）时，取值为[1-9]。 periodType=year（周期类型为年）时，取值为[1-3]。说明：作为请求参数，billingMode为1或2（已废弃）时生效，且为必选。作为响应参数，仅在创建包周期节点时返回。
isAutoRenew	String	是否自动续订 “true”：自动续订 “false”：不自动续订说明： billingMode为1或2（已废弃）时生效，不填写此参数时默认不会自动续费。
isAutoPay	String	是否自动扣款 “true”：自动扣款 “false”：不自动扣款说明： billingMode为1或2（已废弃）时生效，billingMode为1时不填写此参数时默认不会自动扣款。（已废弃：billingMode为2时不填写此参数时默认会自动扣款）
DockerLVMConfigOverride	String	Docker数据盘配置项（已废弃，请使用storage字段）。默认配置示例如下： "DockerLVMConfigOverride":"dockerThinpool=vgpaas/90%VG;kubernetesLV=vgpaas/10%VG;diskType=evs;lvType=linear" 默认配置在无VD类型磁盘时，会由于数据盘查找失败而出错，请根据真实盘符类型填写diskType。包含如下字段： userLV（可选）：用户空间的大小，示例格式：vgpaas/20%VG userPath（可选）：用户空间挂载路径，示例格式：/home/wqt-test diskType：磁盘类型，目前只有evs、hdd和ssd三种格式 lvType：逻辑卷的类型，目前支持linear和striped两种，示例格式：striped dockerThinpool：Docker盘的空间大小，示例格式：vgpaas/60%VG kubernetesLV：Kubelet空间大小，示例格式：vgpaas/20%VG
dockerBaseSize	Integer	节点上单容器的可用磁盘空间大小（已废弃，请优先使用containerBaseSize参数），单位G。不配置该值或值为0时将使用默认值，Devicemapper模式下默认值为10；OverlayFS模式默认不限制单容器可用空间大小，且dockerBaseSize设置仅在新版本集群的EulerOS/HCEOS2.0节点上生效。 CCE节点容器运行时空间配置请参考数据盘空间分配说明。 Devicemapper模式下建议dockerBaseSize配置不超过80G，设置过大时可能会导致容器运行时初始化时间过长而启动失败，若对容器磁盘大小有特殊要求，可考虑使用挂载外部或本地存储方式代替。
containerBaseSize	Integer	节点上单容器的可用磁盘空间大小，单位G。不配置该值或值为0时将使用默认值，OverlayFS模式默认不限制单容器可用空间大小；Devicemapper模式下默认值为10，且containerBaseSize设置仅在新版本集群（v1.23.14-r0/v1.25.9-r0/v1.27.6-r0/v1.28.4-r0及以上）的EulerOS/HCEOS2.0节点上生效。 CCE节点容器运行时空间配置请参考数据盘空间分配说明。 Devicemapper模式下建议containerBaseSize配置不超过80G，设置过大时可能会导致容器运行时初始化时间过长而启动失败，若对容器磁盘大小有特殊要求，可考虑使用挂载外部或本地存储方式代替；Devicemapper模式在新版中仅有共池裸机使用，已逐步废弃。
publicKey	String	节点的公钥。
alpha.cce/preInstall	String	安装前执行脚本。说明：输入的值需要经过Base64编码，方法如下： echo -n "待编码内容" \| base64
alpha.cce/postInstall	String	安装后执行脚本。说明：输入的值需要经过Base64编码，方法如下： echo -n "待编码内容" \| base64
alpha.cce/NodeImageID	String	如果创建裸金属节点，需要使用自定义镜像时用此参数。
nicMultiqueue	String	弹性网卡队列数配置，默认配置示例如下： "[{\"queue\":4}]" 包含如下字段： queue: 弹性网卡队列数。仅在turbo集群的BMS节点时，该字段才可配置。当前支持可配置队列数以及弹性网卡数：{"1":128, "2":92, "4":92, "8":32, "16":16,"28":9}, 既1弹性网卡队列可绑定128张弹性网卡，2队列弹性网卡可绑定92张，以此类推。弹性网卡队列数越多，性能越强，但可绑定弹性网卡数越少，请根据您的需求进行配置（创建后不可修改）。
nicThreshold	String	弹性网卡预绑定比例配置，默认配置示例如下： "0.3:0.6" 第一位小数：预绑定低水位，弹性网卡预绑定的最低比例（最小预绑定弹性网卡数 = ⌊节点的总弹性网卡数 * 预绑定低水位⌋）第二位小数：预绑定高水位，弹性网卡预绑定的最高比例（最大预绑定弹性网卡数 = ⌊节点的总弹性网卡数 * 预绑定高水位⌋） BMS节点上绑定的弹性网卡数：Pod正在使用的弹性网卡数 + 最小预绑定弹性网卡数 < BMS节点上绑定的弹性网卡数 < Pod正在使用的弹性网卡数 + 最大预绑定弹性网卡数 BMS节点上当预绑定弹性网卡数 < 最小预绑定弹性网卡数时：会绑定弹性网卡，使得预绑定弹性网卡数 = 最小预绑定弹性网卡数 BMS节点上当预绑定弹性网卡数 > 最大预绑定弹性网卡数时：会定时解绑弹性网卡（约2分钟一次），直到预绑定弹性网卡数 = 最大预绑定弹性网卡数取值范围：[0.0, 1.0]; 一位小数; 低水位 <= 高水位仅在turbo集群的BMS节点时，该字段才可配置。弹性网卡预绑定能加快工作负载的创建，但会占用IP，请根据您的需求进行配置。
chargingMode	Integer	节点的计费模式。已废弃，请使用NodeSpec中的billingMode字段。
marketType	String	创建竞价实例时，需指定该参数的值为“spot”。说明：仅当billingMode=0时此参数生效
spotPrice	String	用户愿意为竞价实例每小时支付的最高价格。说明：仅当billingMode=0且marketType=spot时，该参数设置后生效。当billingMode=0且marketType=spot时，如果不传递spotPrice，默认使用按需购买的价格作为竞价。 spotPrice需要小于等于按需价格并大于等于云服务器市场价格。
agency_name	String	委托的名称。委托是由租户管理员在统一身份认证服务（Identity and Access Management，IAM）上创建的，可以为CCE节点提供访问云服务器的临时凭证。作为响应参数仅在创建节点传入时返回该字段。
kubeReservedMem	Integer	节点内存预留，Kubernetes相关组件预留值。
systemReservedMem	Integer	节点内存预留，系统组件预留值。
init-node-password	String	节点密码，作为响应参数时，固定展示星号。

**表53** HostnameConfig
参数	参数类型	描述
type	String	K8S节点名称配置类型, 默认为“privateIp”。 privateIp: 将节点私有IP作为K8S节点名称 cceNodeName: 将CCE节点名称作为K8S节点名称说明：配置为cceNodeName的节点, 其节点名称、K8S节点名称以及虚机名称相同。节点名称不支持修改, 并且在ECS侧修改了虚机名称，同步云服务器时，不会将修改后的虚机名称同步到节点。配置为cceNodeName的节点，为了避免K8S节点名称冲突，系统会自动在节点名称后添加后缀，后缀的格式为中划线(-)+五位随机字符，随机字符的取值为[a-z0-9]。

**表54** NodeStatus
参数	参数类型	描述
phase	String	节点状态：节点资源生命周期管理（如安装卸载等）状态和集群内k8s node状态的综合体现，取值如下 Build：创建中，表示节点正处于创建过程中。 Installing：纳管中，表示节点正处于纳管过程中。 Upgrading：升级中，表示节点正处于升级过程中。 Active：正常，表示节点处于正常状态。 Abnormal：异常，表示节点处于异常状态。 Deleting：删除中，表示节点正处于删除过程中。 Error：故障，表示节点处于故障状态。
lastProbeTime	String	节点最近一次状态检查时间。集群处于异常、冻结或者中间态（例如创建中）时，节点的状态检查动作可能受影响。检查时间超过5分的节点状态不具有参考意义。
jobID	String	创建或删除时的任务ID。
serverId	String	底层云服务器或裸金属节点ID。
privateIP	String	节点主网卡私有网段IP地址。
privateIPv6IP	String	节点主网卡私有网段IPv6地址。
publicIP	String	节点弹性公网IP地址。如果ECS的数据没有实时同步，可在界面上通过“同步节点信息”手动进行更新。
deleteStatus	DeleteStatus object	删除资源时表示资源删除状态

**表55** DeleteStatus
参数	参数类型	描述
previous_total	Integer	集群删除时已经存在的集群资源记录总数
current_total	Integer	基于当前集群资源记录信息，生成实际最新资源记录总数
updated	Integer	集群删除时更新的资源记录总数
added	Integer	集群删除时更新的资源记录总数
deleted	Integer	集群删除时删除的资源记录总数

请求示例

创建一个包周期的节点，节点规格为2U4G，节点操作系统为EulerOS 2.5，使用Docker容器引擎。节点系统盘和数据盘大小分别为50GB和100GB，磁盘类型均为高IO。

POST /api/v3/projects/{project_id}/clusters/{cluster_id}/nodes

{
  "kind" : "Node",
  "apiVersion" : "v3",
  "metadata" : {
    "name" : "test-67235"
  },
  "spec" : {
    "flavor" : "c7.large.2",
    "az" : "******",
    "os" : "EulerOS 2.5",
    "dataVolumes" : [ {
      "size" : 100,
      "volumetype" : "SAS"
    } ],
    "billingMode" : 1,
    "extendParam" : {
      "maxPods" : 110,
      "periodType" : "month",
      "periodNum" : 1,
      "isAutoPay" : "false",
      "isAutoRenew" : "false"
    },
    "nodeNicSpec" : {
      "primaryNic" : {
        "subnetId" : "ca964acf-8468-4735-8229-97940ef6c881"
      }
    },
    "rootVolume" : {
      "size" : 50,
      "volumetype" : "SAS"
    },
    "runtime" : {
      "name" : "docker"
    },
    "login" : {
      "sshKey" : "KeyPair-001"
    },
    "storage" : {
      "storageSelectors" : [ {
        "name" : "cceUse",
        "storageType" : "evs",
        "matchLabels" : {
          "size" : "100",
          "volumeType" : "SAS",
          "count" : "1"
        }
      } ],
      "storageGroups" : [ {
        "name" : "vgpaas",
        "selectorNames" : [ "cceUse" ],
        "cceManaged" : true,
        "virtualSpaces" : [ {
          "name" : "runtime",
          "size" : "90%"
        }, {
          "name" : "kubernetes",
          "size" : "10%"
        } ]
      } ]
    },
    "count" : 1
  }
}

创建一个按需计费的节点，节点规格为2U4G，节点操作系统为EulerOS 2.5，使用Docker容器引擎。节点系统盘和数据盘大小分别为50GB和100GB，磁盘类型均为高IO。

POST /api/v3/projects/{project_id}/clusters/{cluster_id}/nodes

{
  "kind" : "Node",
  "apiVersion" : "v3",
  "metadata" : {
    "name" : "test-83790"
  },
  "spec" : {
    "flavor" : "c7.large.2",
    "az" : "******",
    "os" : "EulerOS 2.5",
    "dataVolumes" : [ {
      "size" : 100,
      "volumetype" : "SAS"
    } ],
    "billingMode" : 0,
    "extendParam" : {
      "maxPods" : 110
    },
    "nodeNicSpec" : {
      "primaryNic" : {
        "subnetId" : "ca964acf-8468-4735-8229-97940ef6c881"
      }
    },
    "rootVolume" : {
      "size" : 50,
      "volumetype" : "SAS"
    },
    "runtime" : {
      "name" : "docker"
    },
    "login" : {
      "sshKey" : "KeyPair-001"
    },
    "storage" : {
      "storageSelectors" : [ {
        "name" : "cceUse",
        "storageType" : "evs",
        "matchLabels" : {
          "size" : "100",
          "volumeType" : "SAS",
          "count" : "1"
        }
      } ],
      "storageGroups" : [ {
        "name" : "vgpaas",
        "selectorNames" : [ "cceUse" ],
        "cceManaged" : true,
        "virtualSpaces" : [ {
          "name" : "runtime",
          "size" : "90%"
        }, {
          "name" : "kubernetes",
          "size" : "10%"
        } ]
      } ]
    },
    "count" : 1
  }
}

创建一个按需计费的节点，节点规格为2u4G，节点操作系统为HCE 2.0，使用Docker容器引擎。节点系统盘和数据盘大小分别为50GB和100GB，数据盘使用共享磁盘空间模式。

POST /api/v3/projects/{project_id}/clusters/{cluster_id}/nodes

{
  "kind" : "Node",
  "apiVersion" : "v3",
  "metadata" : {
    "name" : "test-66909"
  },
  "spec" : {
    "flavor" : "c7.large.2",
    "az" : "******",
    "os" : "Huawei Cloud EulerOS 2.0",
    "dataVolumes" : [ {
      "size" : 100,
      "volumetype" : "SAS"
    } ],
    "billingMode" : 0,
    "extendParam" : {
      "maxPods" : 110
    },
    "nodeNicSpec" : {
      "primaryNic" : {
        "subnetId" : "ca964acf-8468-4735-8229-97940ef6c881"
      }
    },
    "rootVolume" : {
      "size" : 50,
      "volumetype" : "SAS"
    },
    "runtime" : {
      "name" : "docker"
    },
    "login" : {
      "sshKey" : "KeyPair-001"
    },
    "storage" : {
      "storageSelectors" : [ {
        "name" : "cceUse",
        "storageType" : "evs",
        "matchLabels" : {
          "size" : "100",
          "volumeType" : "SAS",
          "count" : "1"
        }
      } ],
      "storageGroups" : [ {
        "name" : "vgpaas",
        "selectorNames" : [ "cceUse" ],
        "cceManaged" : true,
        "virtualSpaces" : [ {
          "name" : "share",
          "size" : "100%"
        } ]
      } ]
    },
    "count" : 1
  }
}

响应示例

状态码： 201

表示在指定集群下创建节点的作业下发成功。

{
  "kind" : "Node",
  "apiVersion" : "v3",
  "metadata" : {
    "name" : "test-83790",
    "uid" : "5ecfddfe-87db-11ec-b5e5-0255ac101514",
    "annotations" : {
      "jobid" : "5ec1518c-87db-11ec-b5e5-0255ac101514",
      "resourceJobId" : "5ed0d692-87db-11ec-b5e5-0255ac101514"
    }
  },
  "spec" : {
    "flavor" : "c7.large.2",
    "az" : "******",
    "os" : "EulerOS 2.5",
    "login" : {
      "sshKey" : "KeyPair-001"
    },
    "rootVolume" : {
      "volumetype" : "SAS",
      "size" : 50
    },
    "dataVolumes" : [ {
      "volumetype" : "SAS",
      "size" : 100
    } ],
    "storage" : {
      "storageSelectors" : [ {
        "name" : "cceUse",
        "storageType" : "evs",
        "matchLabels" : {
          "count" : "1",
          "size" : "100",
          "volumeType" : "SAS"
        }
      } ],
      "storageGroups" : [ {
        "name" : "vgpaas",
        "cceManaged" : true,
        "selectorNames" : [ "cceUse" ],
        "virtualSpaces" : [ {
          "name" : "runtime",
          "size" : "90%"
        }, {
          "name" : "kubernetes",
          "size" : "10%"
        } ]
      } ]
    },
    "publicIP" : {
      "eip" : {
        "bandwidth" : { }
      }
    },
    "nodeNicSpec" : {
      "primaryNic" : {
        "subnetId" : "ca964acf-8468-4735-8229-97940ef6c881"
      }
    },
    "count" : 1,
    "billingMode" : 0,
    "runtime" : {
      "name" : "docker"
    },
    "extendParam" : {
      "chargingMode" : 0,
      "ecs:performancetype" : "computingv3",
      "init-node-password" : "******",
      "maxPods" : 110,
      "publicKey" : ""
    }
  },
  "status" : {
    "jobID" : "5ec1518c-87db-11ec-b5e5-0255ac101514"
  }
}

SDK代码示例

SDK代码示例如下。

        
         
           
           
             package com.huaweicloud.sdk.test;

import com.huaweicloud.sdk.core.auth.ICredential;
import com.huaweicloud.sdk.core.auth.BasicCredentials;
import com.huaweicloud.sdk.core.exception.ConnectionException;
import com.huaweicloud.sdk.core.exception.RequestTimeoutException;
import com.huaweicloud.sdk.core.exception.ServiceResponseException;
import com.huaweicloud.sdk.cce.v3.region.CceRegion;
import com.huaweicloud.sdk.cce.v3.*;
import com.huaweicloud.sdk.cce.v3.model.*;
import com.huaweicloud.sdk.cce.v3.model.Runtime;

import java.util.List;
import java.util.ArrayList;

public class CreateNodeSolution {

    public static void main(String[] args) {
        // The AK and SK used for authentication are hard-coded or stored in plaintext, which has great security risks. It is recommended that the AK and SK be stored in ciphertext in configuration files or environment variables and decrypted during use to ensure security.
        // In this example, AK and SK are stored in environment variables for authentication. Before running this example, set environment variables CLOUD_SDK_AK and CLOUD_SDK_SK in the local environment
        String ak = System.getenv("CLOUD_SDK_AK");
        String sk = System.getenv("CLOUD_SDK_SK");
        String projectId = "{project_id}";

        ICredential auth = new BasicCredentials()
                .withProjectId(projectId)
                .withAk(ak)
                .withSk(sk);

        CceClient client = CceClient.newBuilder()
                .withCredential(auth)
                .withRegion(CceRegion.valueOf("<YOUR REGION>"))
                .build();
        CreateNodeRequest request = new CreateNodeRequest();
        request.withClusterId("{cluster_id}");
        NodeCreateRequest body = new NodeCreateRequest();
        NodeExtendParam extendParamSpec = new NodeExtendParam();
        extendParamSpec.withMaxPods(110)
            .withPeriodType("month")
            .withPeriodNum(1)
            .withIsAutoRenew("false")
            .withIsAutoPay("false");
        Runtime runtimeSpec = new Runtime();
        runtimeSpec.withName(Runtime.NameEnum.fromValue("docker"));
        NicSpec primaryNicNodeNicSpec = new NicSpec();
        primaryNicNodeNicSpec.withSubnetId("ca964acf-8468-4735-8229-97940ef6c881");
        NodeNicSpec nodeNicSpecSpec = new NodeNicSpec();
        nodeNicSpecSpec.withPrimaryNic(primaryNicNodeNicSpec);
        List<VirtualSpace> listStorageGroupsVirtualSpaces = new ArrayList<>();
        listStorageGroupsVirtualSpaces.add(
            new VirtualSpace()
                .withName("runtime")
                .withSize("90%")
        );
        listStorageGroupsVirtualSpaces.add(
            new VirtualSpace()
                .withName("kubernetes")
                .withSize("10%")
        );
        List<String> listStorageGroupsSelectorNames = new ArrayList<>();
        listStorageGroupsSelectorNames.add("cceUse");
        List<StorageGroups> listStorageStorageGroups = new ArrayList<>();
        listStorageStorageGroups.add(
            new StorageGroups()
                .withName("vgpaas")
                .withCceManaged(true)
                .withSelectorNames(listStorageGroupsSelectorNames)
                .withVirtualSpaces(listStorageGroupsVirtualSpaces)
        );
        StorageSelectorsMatchLabels matchLabelsStorageSelectors = new StorageSelectorsMatchLabels();
        matchLabelsStorageSelectors.withSize("100")
            .withVolumeType("SAS")
            .withCount("1");
        List<StorageSelectors> listStorageStorageSelectors = new ArrayList<>();
        listStorageStorageSelectors.add(
            new StorageSelectors()
                .withName("cceUse")
                .withStorageType("evs")
                .withMatchLabels(matchLabelsStorageSelectors)
        );
        Storage storageSpec = new Storage();
        storageSpec.withStorageSelectors(listStorageStorageSelectors)
            .withStorageGroups(listStorageStorageGroups);
        List<Volume> listSpecDataVolumes = new ArrayList<>();
        listSpecDataVolumes.add(
            new Volume()
                .withSize(100)
                .withVolumetype("SAS")
        );
        Volume rootVolumeSpec = new Volume();
        rootVolumeSpec.withSize(50)
            .withVolumetype("SAS");
        Login loginSpec = new Login();
        loginSpec.withSshKey("KeyPair-001");
        NodeSpec specbody = new NodeSpec();
        specbody.withFlavor("c7.large.2")
            .withAz("******")
            .withOs("EulerOS 2.5")
            .withLogin(loginSpec)
            .withRootVolume(rootVolumeSpec)
            .withDataVolumes(listSpecDataVolumes)
            .withStorage(storageSpec)
            .withNodeNicSpec(nodeNicSpecSpec)
            .withCount(1)
            .withBillingMode(1)
            .withRuntime(runtimeSpec)
            .withExtendParam(extendParamSpec);
        NodeMetadata metadatabody = new NodeMetadata();
        metadatabody.withName("test-67235");
        body.withSpec(specbody);
        body.withMetadata(metadatabody);
        body.withApiVersion("v3");
        body.withKind("Node");
        request.withBody(body);
        try {
            CreateNodeResponse response = client.createNode(request);
            System.out.println(response.toString());
        } catch (ConnectionException e) {
            e.printStackTrace();
        } catch (RequestTimeoutException e) {
            e.printStackTrace();
        } catch (ServiceResponseException e) {
            e.printStackTrace();
            System.out.println(e.getHttpStatusCode());
            System.out.println(e.getRequestId());
            System.out.println(e.getErrorCode());
            System.out.println(e.getErrorMsg());
        }
    }
}

            

          

        
       

        
         
           
           
             package com.huaweicloud.sdk.test;

import com.huaweicloud.sdk.core.auth.ICredential;
import com.huaweicloud.sdk.core.auth.BasicCredentials;
import com.huaweicloud.sdk.core.exception.ConnectionException;
import com.huaweicloud.sdk.core.exception.RequestTimeoutException;
import com.huaweicloud.sdk.core.exception.ServiceResponseException;
import com.huaweicloud.sdk.cce.v3.region.CceRegion;
import com.huaweicloud.sdk.cce.v3.*;
import com.huaweicloud.sdk.cce.v3.model.*;
import com.huaweicloud.sdk.cce.v3.model.Runtime;

import java.util.List;
import java.util.ArrayList;

public class CreateNodeSolution {

    public static void main(String[] args) {
        // The AK and SK used for authentication are hard-coded or stored in plaintext, which has great security risks. It is recommended that the AK and SK be stored in ciphertext in configuration files or environment variables and decrypted during use to ensure security.
        // In this example, AK and SK are stored in environment variables for authentication. Before running this example, set environment variables CLOUD_SDK_AK and CLOUD_SDK_SK in the local environment
        String ak = System.getenv("CLOUD_SDK_AK");
        String sk = System.getenv("CLOUD_SDK_SK");
        String projectId = "{project_id}";

        ICredential auth = new BasicCredentials()
                .withProjectId(projectId)
                .withAk(ak)
                .withSk(sk);

        CceClient client = CceClient.newBuilder()
                .withCredential(auth)
                .withRegion(CceRegion.valueOf("<YOUR REGION>"))
                .build();
        CreateNodeRequest request = new CreateNodeRequest();
        request.withClusterId("{cluster_id}");
        NodeCreateRequest body = new NodeCreateRequest();
        NodeExtendParam extendParamSpec = new NodeExtendParam();
        extendParamSpec.withMaxPods(110);
        Runtime runtimeSpec = new Runtime();
        runtimeSpec.withName(Runtime.NameEnum.fromValue("docker"));
        NicSpec primaryNicNodeNicSpec = new NicSpec();
        primaryNicNodeNicSpec.withSubnetId("ca964acf-8468-4735-8229-97940ef6c881");
        NodeNicSpec nodeNicSpecSpec = new NodeNicSpec();
        nodeNicSpecSpec.withPrimaryNic(primaryNicNodeNicSpec);
        List<VirtualSpace> listStorageGroupsVirtualSpaces = new ArrayList<>();
        listStorageGroupsVirtualSpaces.add(
            new VirtualSpace()
                .withName("runtime")
                .withSize("90%")
        );
        listStorageGroupsVirtualSpaces.add(
            new VirtualSpace()
                .withName("kubernetes")
                .withSize("10%")
        );
        List<String> listStorageGroupsSelectorNames = new ArrayList<>();
        listStorageGroupsSelectorNames.add("cceUse");
        List<StorageGroups> listStorageStorageGroups = new ArrayList<>();
        listStorageStorageGroups.add(
            new StorageGroups()
                .withName("vgpaas")
                .withCceManaged(true)
                .withSelectorNames(listStorageGroupsSelectorNames)
                .withVirtualSpaces(listStorageGroupsVirtualSpaces)
        );
        StorageSelectorsMatchLabels matchLabelsStorageSelectors = new StorageSelectorsMatchLabels();
        matchLabelsStorageSelectors.withSize("100")
            .withVolumeType("SAS")
            .withCount("1");
        List<StorageSelectors> listStorageStorageSelectors = new ArrayList<>();
        listStorageStorageSelectors.add(
            new StorageSelectors()
                .withName("cceUse")
                .withStorageType("evs")
                .withMatchLabels(matchLabelsStorageSelectors)
        );
        Storage storageSpec = new Storage();
        storageSpec.withStorageSelectors(listStorageStorageSelectors)
            .withStorageGroups(listStorageStorageGroups);
        List<Volume> listSpecDataVolumes = new ArrayList<>();
        listSpecDataVolumes.add(
            new Volume()
                .withSize(100)
                .withVolumetype("SAS")
        );
        Volume rootVolumeSpec = new Volume();
        rootVolumeSpec.withSize(50)
            .withVolumetype("SAS");
        Login loginSpec = new Login();
        loginSpec.withSshKey("KeyPair-001");
        NodeSpec specbody = new NodeSpec();
        specbody.withFlavor("c7.large.2")
            .withAz("******")
            .withOs("EulerOS 2.5")
            .withLogin(loginSpec)
            .withRootVolume(rootVolumeSpec)
            .withDataVolumes(listSpecDataVolumes)
            .withStorage(storageSpec)
            .withNodeNicSpec(nodeNicSpecSpec)
            .withCount(1)
            .withBillingMode(0)
            .withRuntime(runtimeSpec)
            .withExtendParam(extendParamSpec);
        NodeMetadata metadatabody = new NodeMetadata();
        metadatabody.withName("test-83790");
        body.withSpec(specbody);
        body.withMetadata(metadatabody);
        body.withApiVersion("v3");
        body.withKind("Node");
        request.withBody(body);
        try {
            CreateNodeResponse response = client.createNode(request);
            System.out.println(response.toString());
        } catch (ConnectionException e) {
            e.printStackTrace();
        } catch (RequestTimeoutException e) {
            e.printStackTrace();
        } catch (ServiceResponseException e) {
            e.printStackTrace();
            System.out.println(e.getHttpStatusCode());
            System.out.println(e.getRequestId());
            System.out.println(e.getErrorCode());
            System.out.println(e.getErrorMsg());
        }
    }
}

            

          

        
       

        
         
           
           
             package com.huaweicloud.sdk.test;

import com.huaweicloud.sdk.core.auth.ICredential;
import com.huaweicloud.sdk.core.auth.BasicCredentials;
import com.huaweicloud.sdk.core.exception.ConnectionException;
import com.huaweicloud.sdk.core.exception.RequestTimeoutException;
import com.huaweicloud.sdk.core.exception.ServiceResponseException;
import com.huaweicloud.sdk.cce.v3.region.CceRegion;
import com.huaweicloud.sdk.cce.v3.*;
import com.huaweicloud.sdk.cce.v3.model.*;
import com.huaweicloud.sdk.cce.v3.model.Runtime;

import java.util.List;
import java.util.ArrayList;

public class CreateNodeSolution {

    public static void main(String[] args) {
        // The AK and SK used for authentication are hard-coded or stored in plaintext, which has great security risks. It is recommended that the AK and SK be stored in ciphertext in configuration files or environment variables and decrypted during use to ensure security.
        // In this example, AK and SK are stored in environment variables for authentication. Before running this example, set environment variables CLOUD_SDK_AK and CLOUD_SDK_SK in the local environment
        String ak = System.getenv("CLOUD_SDK_AK");
        String sk = System.getenv("CLOUD_SDK_SK");
        String projectId = "{project_id}";

        ICredential auth = new BasicCredentials()
                .withProjectId(projectId)
                .withAk(ak)
                .withSk(sk);

        CceClient client = CceClient.newBuilder()
                .withCredential(auth)
                .withRegion(CceRegion.valueOf("<YOUR REGION>"))
                .build();
        CreateNodeRequest request = new CreateNodeRequest();
        request.withClusterId("{cluster_id}");
        NodeCreateRequest body = new NodeCreateRequest();
        NodeExtendParam extendParamSpec = new NodeExtendParam();
        extendParamSpec.withMaxPods(110);
        Runtime runtimeSpec = new Runtime();
        runtimeSpec.withName(Runtime.NameEnum.fromValue("docker"));
        NicSpec primaryNicNodeNicSpec = new NicSpec();
        primaryNicNodeNicSpec.withSubnetId("ca964acf-8468-4735-8229-97940ef6c881");
        NodeNicSpec nodeNicSpecSpec = new NodeNicSpec();
        nodeNicSpecSpec.withPrimaryNic(primaryNicNodeNicSpec);
        List<VirtualSpace> listStorageGroupsVirtualSpaces = new ArrayList<>();
        listStorageGroupsVirtualSpaces.add(
            new VirtualSpace()
                .withName("share")
                .withSize("100%")
        );
        List<String> listStorageGroupsSelectorNames = new ArrayList<>();
        listStorageGroupsSelectorNames.add("cceUse");
        List<StorageGroups> listStorageStorageGroups = new ArrayList<>();
        listStorageStorageGroups.add(
            new StorageGroups()
                .withName("vgpaas")
                .withCceManaged(true)
                .withSelectorNames(listStorageGroupsSelectorNames)
                .withVirtualSpaces(listStorageGroupsVirtualSpaces)
        );
        StorageSelectorsMatchLabels matchLabelsStorageSelectors = new StorageSelectorsMatchLabels();
        matchLabelsStorageSelectors.withSize("100")
            .withVolumeType("SAS")
            .withCount("1");
        List<StorageSelectors> listStorageStorageSelectors = new ArrayList<>();
        listStorageStorageSelectors.add(
            new StorageSelectors()
                .withName("cceUse")
                .withStorageType("evs")
                .withMatchLabels(matchLabelsStorageSelectors)
        );
        Storage storageSpec = new Storage();
        storageSpec.withStorageSelectors(listStorageStorageSelectors)
            .withStorageGroups(listStorageStorageGroups);
        List<Volume> listSpecDataVolumes = new ArrayList<>();
        listSpecDataVolumes.add(
            new Volume()
                .withSize(100)
                .withVolumetype("SAS")
        );
        Volume rootVolumeSpec = new Volume();
        rootVolumeSpec.withSize(50)
            .withVolumetype("SAS");
        Login loginSpec = new Login();
        loginSpec.withSshKey("KeyPair-001");
        NodeSpec specbody = new NodeSpec();
        specbody.withFlavor("c7.large.2")
            .withAz("******")
            .withOs("Huawei Cloud EulerOS 2.0")
            .withLogin(loginSpec)
            .withRootVolume(rootVolumeSpec)
            .withDataVolumes(listSpecDataVolumes)
            .withStorage(storageSpec)
            .withNodeNicSpec(nodeNicSpecSpec)
            .withCount(1)
            .withBillingMode(0)
            .withRuntime(runtimeSpec)
            .withExtendParam(extendParamSpec);
        NodeMetadata metadatabody = new NodeMetadata();
        metadatabody.withName("test-66909");
        body.withSpec(specbody);
        body.withMetadata(metadatabody);
        body.withApiVersion("v3");
        body.withKind("Node");
        request.withBody(body);
        try {
            CreateNodeResponse response = client.createNode(request);
            System.out.println(response.toString());
        } catch (ConnectionException e) {
            e.printStackTrace();
        } catch (RequestTimeoutException e) {
            e.printStackTrace();
        } catch (ServiceResponseException e) {
            e.printStackTrace();
            System.out.println(e.getHttpStatusCode());
            System.out.println(e.getRequestId());
            System.out.println(e.getErrorCode());
            System.out.println(e.getErrorMsg());
        }
    }
}

            

          

        
       

        
         
           
           
             # coding: utf-8

import os
from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkcce.v3.region.cce_region import CceRegion
from huaweicloudsdkcore.exceptions import exceptions
from huaweicloudsdkcce.v3 import *

if __name__ == "__main__":
    # The AK and SK used for authentication are hard-coded or stored in plaintext, which has great security risks. It is recommended that the AK and SK be stored in ciphertext in configuration files or environment variables and decrypted during use to ensure security.
    # In this example, AK and SK are stored in environment variables for authentication. Before running this example, set environment variables CLOUD_SDK_AK and CLOUD_SDK_SK in the local environment
    ak = os.environ["CLOUD_SDK_AK"]
    sk = os.environ["CLOUD_SDK_SK"]
    projectId = "{project_id}"

    credentials = BasicCredentials(ak, sk, projectId)

    client = CceClient.new_builder() \
        .with_credentials(credentials) \
        .with_region(CceRegion.value_of("<YOUR REGION>")) \
        .build()

    try:
        request = CreateNodeRequest()
        request.cluster_id = "{cluster_id}"
        extendParamSpec = NodeExtendParam(
            max_pods=110,
            period_type="month",
            period_num=1,
            is_auto_renew="false",
            is_auto_pay="false"
        )
        runtimeSpec = Runtime(
            name="docker"
        )
        primaryNicNodeNicSpec = NicSpec(
            subnet_id="ca964acf-8468-4735-8229-97940ef6c881"
        )
        nodeNicSpecSpec = NodeNicSpec(
            primary_nic=primaryNicNodeNicSpec
        )
        listVirtualSpacesStorageGroups = [
            VirtualSpace(
                name="runtime",
                size="90%"
            ),
            VirtualSpace(
                name="kubernetes",
                size="10%"
            )
        ]
        listSelectorNamesStorageGroups = [
            "cceUse"
        ]
        listStorageGroupsStorage = [
            StorageGroups(
                name="vgpaas",
                cce_managed=True,
                selector_names=listSelectorNamesStorageGroups,
                virtual_spaces=listVirtualSpacesStorageGroups
            )
        ]
        matchLabelsStorageSelectors = StorageSelectorsMatchLabels(
            size="100",
            volume_type="SAS",
            count="1"
        )
        listStorageSelectorsStorage = [
            StorageSelectors(
                name="cceUse",
                storage_type="evs",
                match_labels=matchLabelsStorageSelectors
            )
        ]
        storageSpec = Storage(
            storage_selectors=listStorageSelectorsStorage,
            storage_groups=listStorageGroupsStorage
        )
        listDataVolumesSpec = [
            Volume(
                size=100,
                volumetype="SAS"
            )
        ]
        rootVolumeSpec = Volume(
            size=50,
            volumetype="SAS"
        )
        loginSpec = Login(
            ssh_key="KeyPair-001"
        )
        specbody = NodeSpec(
            flavor="c7.large.2",
            az="******",
            os="EulerOS 2.5",
            login=loginSpec,
            root_volume=rootVolumeSpec,
            data_volumes=listDataVolumesSpec,
            storage=storageSpec,
            node_nic_spec=nodeNicSpecSpec,
            count=1,
            billing_mode=1,
            runtime=runtimeSpec,
            extend_param=extendParamSpec
        )
        metadatabody = NodeMetadata(
            name="test-67235"
        )
        request.body = NodeCreateRequest(
            spec=specbody,
            metadata=metadatabody,
            api_version="v3",
            kind="Node"
        )
        response = client.create_node(request)
        print(response)
    except exceptions.ClientRequestException as e:
        print(e.status_code)
        print(e.request_id)
        print(e.error_code)
        print(e.error_msg)

            

          

        
       

        
         
           
           
             # coding: utf-8

import os
from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkcce.v3.region.cce_region import CceRegion
from huaweicloudsdkcore.exceptions import exceptions
from huaweicloudsdkcce.v3 import *

if __name__ == "__main__":
    # The AK and SK used for authentication are hard-coded or stored in plaintext, which has great security risks. It is recommended that the AK and SK be stored in ciphertext in configuration files or environment variables and decrypted during use to ensure security.
    # In this example, AK and SK are stored in environment variables for authentication. Before running this example, set environment variables CLOUD_SDK_AK and CLOUD_SDK_SK in the local environment
    ak = os.environ["CLOUD_SDK_AK"]
    sk = os.environ["CLOUD_SDK_SK"]
    projectId = "{project_id}"

    credentials = BasicCredentials(ak, sk, projectId)

    client = CceClient.new_builder() \
        .with_credentials(credentials) \
        .with_region(CceRegion.value_of("<YOUR REGION>")) \
        .build()

    try:
        request = CreateNodeRequest()
        request.cluster_id = "{cluster_id}"
        extendParamSpec = NodeExtendParam(
            max_pods=110
        )
        runtimeSpec = Runtime(
            name="docker"
        )
        primaryNicNodeNicSpec = NicSpec(
            subnet_id="ca964acf-8468-4735-8229-97940ef6c881"
        )
        nodeNicSpecSpec = NodeNicSpec(
            primary_nic=primaryNicNodeNicSpec
        )
        listVirtualSpacesStorageGroups = [
            VirtualSpace(
                name="runtime",
                size="90%"
            ),
            VirtualSpace(
                name="kubernetes",
                size="10%"
            )
        ]
        listSelectorNamesStorageGroups = [
            "cceUse"
        ]
        listStorageGroupsStorage = [
            StorageGroups(
                name="vgpaas",
                cce_managed=True,
                selector_names=listSelectorNamesStorageGroups,
                virtual_spaces=listVirtualSpacesStorageGroups
            )
        ]
        matchLabelsStorageSelectors = StorageSelectorsMatchLabels(
            size="100",
            volume_type="SAS",
            count="1"
        )
        listStorageSelectorsStorage = [
            StorageSelectors(
                name="cceUse",
                storage_type="evs",
                match_labels=matchLabelsStorageSelectors
            )
        ]
        storageSpec = Storage(
            storage_selectors=listStorageSelectorsStorage,
            storage_groups=listStorageGroupsStorage
        )
        listDataVolumesSpec = [
            Volume(
                size=100,
                volumetype="SAS"
            )
        ]
        rootVolumeSpec = Volume(
            size=50,
            volumetype="SAS"
        )
        loginSpec = Login(
            ssh_key="KeyPair-001"
        )
        specbody = NodeSpec(
            flavor="c7.large.2",
            az="******",
            os="EulerOS 2.5",
            login=loginSpec,
            root_volume=rootVolumeSpec,
            data_volumes=listDataVolumesSpec,
            storage=storageSpec,
            node_nic_spec=nodeNicSpecSpec,
            count=1,
            billing_mode=0,
            runtime=runtimeSpec,
            extend_param=extendParamSpec
        )
        metadatabody = NodeMetadata(
            name="test-83790"
        )
        request.body = NodeCreateRequest(
            spec=specbody,
            metadata=metadatabody,
            api_version="v3",
            kind="Node"
        )
        response = client.create_node(request)
        print(response)
    except exceptions.ClientRequestException as e:
        print(e.status_code)
        print(e.request_id)
        print(e.error_code)
        print(e.error_msg)

            

          

        
       

        
         
           
           
             # coding: utf-8

import os
from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkcce.v3.region.cce_region import CceRegion
from huaweicloudsdkcore.exceptions import exceptions
from huaweicloudsdkcce.v3 import *

if __name__ == "__main__":
    # The AK and SK used for authentication are hard-coded or stored in plaintext, which has great security risks. It is recommended that the AK and SK be stored in ciphertext in configuration files or environment variables and decrypted during use to ensure security.
    # In this example, AK and SK are stored in environment variables for authentication. Before running this example, set environment variables CLOUD_SDK_AK and CLOUD_SDK_SK in the local environment
    ak = os.environ["CLOUD_SDK_AK"]
    sk = os.environ["CLOUD_SDK_SK"]
    projectId = "{project_id}"

    credentials = BasicCredentials(ak, sk, projectId)

    client = CceClient.new_builder() \
        .with_credentials(credentials) \
        .with_region(CceRegion.value_of("<YOUR REGION>")) \
        .build()

    try:
        request = CreateNodeRequest()
        request.cluster_id = "{cluster_id}"
        extendParamSpec = NodeExtendParam(
            max_pods=110
        )
        runtimeSpec = Runtime(
            name="docker"
        )
        primaryNicNodeNicSpec = NicSpec(
            subnet_id="ca964acf-8468-4735-8229-97940ef6c881"
        )
        nodeNicSpecSpec = NodeNicSpec(
            primary_nic=primaryNicNodeNicSpec
        )
        listVirtualSpacesStorageGroups = [
            VirtualSpace(
                name="share",
                size="100%"
            )
        ]
        listSelectorNamesStorageGroups = [
            "cceUse"
        ]
        listStorageGroupsStorage = [
            StorageGroups(
                name="vgpaas",
                cce_managed=True,
                selector_names=listSelectorNamesStorageGroups,
                virtual_spaces=listVirtualSpacesStorageGroups
            )
        ]
        matchLabelsStorageSelectors = StorageSelectorsMatchLabels(
            size="100",
            volume_type="SAS",
            count="1"
        )
        listStorageSelectorsStorage = [
            StorageSelectors(
                name="cceUse",
                storage_type="evs",
                match_labels=matchLabelsStorageSelectors
            )
        ]
        storageSpec = Storage(
            storage_selectors=listStorageSelectorsStorage,
            storage_groups=listStorageGroupsStorage
        )
        listDataVolumesSpec = [
            Volume(
                size=100,
                volumetype="SAS"
            )
        ]
        rootVolumeSpec = Volume(
            size=50,
            volumetype="SAS"
        )
        loginSpec = Login(
            ssh_key="KeyPair-001"
        )
        specbody = NodeSpec(
            flavor="c7.large.2",
            az="******",
            os="Huawei Cloud EulerOS 2.0",
            login=loginSpec,
            root_volume=rootVolumeSpec,
            data_volumes=listDataVolumesSpec,
            storage=storageSpec,
            node_nic_spec=nodeNicSpecSpec,
            count=1,
            billing_mode=0,
            runtime=runtimeSpec,
            extend_param=extendParamSpec
        )
        metadatabody = NodeMetadata(
            name="test-66909"
        )
        request.body = NodeCreateRequest(
            spec=specbody,
            metadata=metadatabody,
            api_version="v3",
            kind="Node"
        )
        response = client.create_node(request)
        print(response)
    except exceptions.ClientRequestException as e:
        print(e.status_code)
        print(e.request_id)
        print(e.error_code)
        print(e.error_msg)

            

          

        
       

        
         
           
           
             package main

import (
	"fmt"
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/core/auth/basic"
    cce "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/cce/v3"
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/services/cce/v3/model"
    region "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/cce/v3/region"
)

func main() {
    // The AK and SK used for authentication are hard-coded or stored in plaintext, which has great security risks. It is recommended that the AK and SK be stored in ciphertext in configuration files or environment variables and decrypted during use to ensure security.
    // In this example, AK and SK are stored in environment variables for authentication. Before running this example, set environment variables CLOUD_SDK_AK and CLOUD_SDK_SK in the local environment
    ak := os.Getenv("CLOUD_SDK_AK")
    sk := os.Getenv("CLOUD_SDK_SK")
    projectId := "{project_id}"

    auth := basic.NewCredentialsBuilder().
        WithAk(ak).
        WithSk(sk).
        WithProjectId(projectId).
        Build()

    client := cce.NewCceClient(
        cce.CceClientBuilder().
            WithRegion(region.ValueOf("<YOUR REGION>")).
            WithCredential(auth).
            Build())

    request := &model.CreateNodeRequest{}
	request.ClusterId = "{cluster_id}"
	maxPodsExtendParam:= int32(110)
	periodTypeExtendParam:= "month"
	periodNumExtendParam:= int32(1)
	isAutoRenewExtendParam:= "false"
	isAutoPayExtendParam:= "false"
	extendParamSpec := &model.NodeExtendParam{
		MaxPods: &maxPodsExtendParam,
		PeriodType: &periodTypeExtendParam,
		PeriodNum: &periodNumExtendParam,
		IsAutoRenew: &isAutoRenewExtendParam,
		IsAutoPay: &isAutoPayExtendParam,
	}
	nameRuntime:= model.GetRuntimeNameEnum().DOCKER
	runtimeSpec := &model.Runtime{
		Name: &nameRuntime,
	}
	subnetIdPrimaryNic:= "ca964acf-8468-4735-8229-97940ef6c881"
	primaryNicNodeNicSpec := &model.NicSpec{
		SubnetId: &subnetIdPrimaryNic,
	}
	nodeNicSpecSpec := &model.NodeNicSpec{
		PrimaryNic: primaryNicNodeNicSpec,
	}
	var listVirtualSpacesStorageGroups = []model.VirtualSpace{
        {
            Name: "runtime",
            Size: "90%",
        },
        {
            Name: "kubernetes",
            Size: "10%",
        },
    }
	var listSelectorNamesStorageGroups = []string{
        "cceUse",
    }
	cceManagedStorageGroups:= true
	var listStorageGroupsStorage = []model.StorageGroups{
        {
            Name: "vgpaas",
            CceManaged: &cceManagedStorageGroups,
            SelectorNames: listSelectorNamesStorageGroups,
            VirtualSpaces: listVirtualSpacesStorageGroups,
        },
    }
	sizeMatchLabels:= "100"
	volumeTypeMatchLabels:= "SAS"
	countMatchLabels:= "1"
	matchLabelsStorageSelectors := &model.StorageSelectorsMatchLabels{
		Size: &sizeMatchLabels,
		VolumeType: &volumeTypeMatchLabels,
		Count: &countMatchLabels,
	}
	var listStorageSelectorsStorage = []model.StorageSelectors{
        {
            Name: "cceUse",
            StorageType: "evs",
            MatchLabels: matchLabelsStorageSelectors,
        },
    }
	storageSpec := &model.Storage{
		StorageSelectors: listStorageSelectorsStorage,
		StorageGroups: listStorageGroupsStorage,
	}
	var listDataVolumesSpec = []model.Volume{
        {
            Size: int32(100),
            Volumetype: "SAS",
        },
    }
	rootVolumeSpec := &model.Volume{
		Size: int32(50),
		Volumetype: "SAS",
	}
	sshKeyLogin:= "KeyPair-001"
	loginSpec := &model.Login{
		SshKey: &sshKeyLogin,
	}
	osSpec:= "EulerOS 2.5"
	countSpec:= int32(1)
	billingModeSpec:= int32(1)
	specbody := &model.NodeSpec{
		Flavor: "c7.large.2",
		Az: "******",
		Os: &osSpec,
		Login: loginSpec,
		RootVolume: rootVolumeSpec,
		DataVolumes: listDataVolumesSpec,
		Storage: storageSpec,
		NodeNicSpec: nodeNicSpecSpec,
		Count: &countSpec,
		BillingMode: &billingModeSpec,
		Runtime: runtimeSpec,
		ExtendParam: extendParamSpec,
	}
	nameMetadata:= "test-67235"
	metadatabody := &model.NodeMetadata{
		Name: &nameMetadata,
	}
	request.Body = &model.NodeCreateRequest{
		Spec: specbody,
		Metadata: metadatabody,
		ApiVersion: "v3",
		Kind: "Node",
	}
	response, err := client.CreateNode(request)
	if err == nil {
        fmt.Printf("%+v\n", response)
    } else {
        fmt.Println(err)
    }
}

            

          

        
       

        
         
           
           
             package main

import (
	"fmt"
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/core/auth/basic"
    cce "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/cce/v3"
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/services/cce/v3/model"
    region "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/cce/v3/region"
)

func main() {
    // The AK and SK used for authentication are hard-coded or stored in plaintext, which has great security risks. It is recommended that the AK and SK be stored in ciphertext in configuration files or environment variables and decrypted during use to ensure security.
    // In this example, AK and SK are stored in environment variables for authentication. Before running this example, set environment variables CLOUD_SDK_AK and CLOUD_SDK_SK in the local environment
    ak := os.Getenv("CLOUD_SDK_AK")
    sk := os.Getenv("CLOUD_SDK_SK")
    projectId := "{project_id}"

    auth := basic.NewCredentialsBuilder().
        WithAk(ak).
        WithSk(sk).
        WithProjectId(projectId).
        Build()

    client := cce.NewCceClient(
        cce.CceClientBuilder().
            WithRegion(region.ValueOf("<YOUR REGION>")).
            WithCredential(auth).
            Build())

    request := &model.CreateNodeRequest{}
	request.ClusterId = "{cluster_id}"
	maxPodsExtendParam:= int32(110)
	extendParamSpec := &model.NodeExtendParam{
		MaxPods: &maxPodsExtendParam,
	}
	nameRuntime:= model.GetRuntimeNameEnum().DOCKER
	runtimeSpec := &model.Runtime{
		Name: &nameRuntime,
	}
	subnetIdPrimaryNic:= "ca964acf-8468-4735-8229-97940ef6c881"
	primaryNicNodeNicSpec := &model.NicSpec{
		SubnetId: &subnetIdPrimaryNic,
	}
	nodeNicSpecSpec := &model.NodeNicSpec{
		PrimaryNic: primaryNicNodeNicSpec,
	}
	var listVirtualSpacesStorageGroups = []model.VirtualSpace{
        {
            Name: "runtime",
            Size: "90%",
        },
        {
            Name: "kubernetes",
            Size: "10%",
        },
    }
	var listSelectorNamesStorageGroups = []string{
        "cceUse",
    }
	cceManagedStorageGroups:= true
	var listStorageGroupsStorage = []model.StorageGroups{
        {
            Name: "vgpaas",
            CceManaged: &cceManagedStorageGroups,
            SelectorNames: listSelectorNamesStorageGroups,
            VirtualSpaces: listVirtualSpacesStorageGroups,
        },
    }
	sizeMatchLabels:= "100"
	volumeTypeMatchLabels:= "SAS"
	countMatchLabels:= "1"
	matchLabelsStorageSelectors := &model.StorageSelectorsMatchLabels{
		Size: &sizeMatchLabels,
		VolumeType: &volumeTypeMatchLabels,
		Count: &countMatchLabels,
	}
	var listStorageSelectorsStorage = []model.StorageSelectors{
        {
            Name: "cceUse",
            StorageType: "evs",
            MatchLabels: matchLabelsStorageSelectors,
        },
    }
	storageSpec := &model.Storage{
		StorageSelectors: listStorageSelectorsStorage,
		StorageGroups: listStorageGroupsStorage,
	}
	var listDataVolumesSpec = []model.Volume{
        {
            Size: int32(100),
            Volumetype: "SAS",
        },
    }
	rootVolumeSpec := &model.Volume{
		Size: int32(50),
		Volumetype: "SAS",
	}
	sshKeyLogin:= "KeyPair-001"
	loginSpec := &model.Login{
		SshKey: &sshKeyLogin,
	}
	osSpec:= "EulerOS 2.5"
	countSpec:= int32(1)
	billingModeSpec:= int32(0)
	specbody := &model.NodeSpec{
		Flavor: "c7.large.2",
		Az: "******",
		Os: &osSpec,
		Login: loginSpec,
		RootVolume: rootVolumeSpec,
		DataVolumes: listDataVolumesSpec,
		Storage: storageSpec,
		NodeNicSpec: nodeNicSpecSpec,
		Count: &countSpec,
		BillingMode: &billingModeSpec,
		Runtime: runtimeSpec,
		ExtendParam: extendParamSpec,
	}
	nameMetadata:= "test-83790"
	metadatabody := &model.NodeMetadata{
		Name: &nameMetadata,
	}
	request.Body = &model.NodeCreateRequest{
		Spec: specbody,
		Metadata: metadatabody,
		ApiVersion: "v3",
		Kind: "Node",
	}
	response, err := client.CreateNode(request)
	if err == nil {
        fmt.Printf("%+v\n", response)
    } else {
        fmt.Println(err)
    }
}

            

          

        
       

        
         
           
           
             package main

import (
	"fmt"
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/core/auth/basic"
    cce "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/cce/v3"
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/services/cce/v3/model"
    region "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/cce/v3/region"
)

func main() {
    // The AK and SK used for authentication are hard-coded or stored in plaintext, which has great security risks. It is recommended that the AK and SK be stored in ciphertext in configuration files or environment variables and decrypted during use to ensure security.
    // In this example, AK and SK are stored in environment variables for authentication. Before running this example, set environment variables CLOUD_SDK_AK and CLOUD_SDK_SK in the local environment
    ak := os.Getenv("CLOUD_SDK_AK")
    sk := os.Getenv("CLOUD_SDK_SK")
    projectId := "{project_id}"

    auth := basic.NewCredentialsBuilder().
        WithAk(ak).
        WithSk(sk).
        WithProjectId(projectId).
        Build()

    client := cce.NewCceClient(
        cce.CceClientBuilder().
            WithRegion(region.ValueOf("<YOUR REGION>")).
            WithCredential(auth).
            Build())

    request := &model.CreateNodeRequest{}
	request.ClusterId = "{cluster_id}"
	maxPodsExtendParam:= int32(110)
	extendParamSpec := &model.NodeExtendParam{
		MaxPods: &maxPodsExtendParam,
	}
	nameRuntime:= model.GetRuntimeNameEnum().DOCKER
	runtimeSpec := &model.Runtime{
		Name: &nameRuntime,
	}
	subnetIdPrimaryNic:= "ca964acf-8468-4735-8229-97940ef6c881"
	primaryNicNodeNicSpec := &model.NicSpec{
		SubnetId: &subnetIdPrimaryNic,
	}
	nodeNicSpecSpec := &model.NodeNicSpec{
		PrimaryNic: primaryNicNodeNicSpec,
	}
	var listVirtualSpacesStorageGroups = []model.VirtualSpace{
        {
            Name: "share",
            Size: "100%",
        },
    }
	var listSelectorNamesStorageGroups = []string{
        "cceUse",
    }
	cceManagedStorageGroups:= true
	var listStorageGroupsStorage = []model.StorageGroups{
        {
            Name: "vgpaas",
            CceManaged: &cceManagedStorageGroups,
            SelectorNames: listSelectorNamesStorageGroups,
            VirtualSpaces: listVirtualSpacesStorageGroups,
        },
    }
	sizeMatchLabels:= "100"
	volumeTypeMatchLabels:= "SAS"
	countMatchLabels:= "1"
	matchLabelsStorageSelectors := &model.StorageSelectorsMatchLabels{
		Size: &sizeMatchLabels,
		VolumeType: &volumeTypeMatchLabels,
		Count: &countMatchLabels,
	}
	var listStorageSelectorsStorage = []model.StorageSelectors{
        {
            Name: "cceUse",
            StorageType: "evs",
            MatchLabels: matchLabelsStorageSelectors,
        },
    }
	storageSpec := &model.Storage{
		StorageSelectors: listStorageSelectorsStorage,
		StorageGroups: listStorageGroupsStorage,
	}
	var listDataVolumesSpec = []model.Volume{
        {
            Size: int32(100),
            Volumetype: "SAS",
        },
    }
	rootVolumeSpec := &model.Volume{
		Size: int32(50),
		Volumetype: "SAS",
	}
	sshKeyLogin:= "KeyPair-001"
	loginSpec := &model.Login{
		SshKey: &sshKeyLogin,
	}
	osSpec:= "Huawei Cloud EulerOS 2.0"
	countSpec:= int32(1)
	billingModeSpec:= int32(0)
	specbody := &model.NodeSpec{
		Flavor: "c7.large.2",
		Az: "******",
		Os: &osSpec,
		Login: loginSpec,
		RootVolume: rootVolumeSpec,
		DataVolumes: listDataVolumesSpec,
		Storage: storageSpec,
		NodeNicSpec: nodeNicSpecSpec,
		Count: &countSpec,
		BillingMode: &billingModeSpec,
		Runtime: runtimeSpec,
		ExtendParam: extendParamSpec,
	}
	nameMetadata:= "test-66909"
	metadatabody := &model.NodeMetadata{
		Name: &nameMetadata,
	}
	request.Body = &model.NodeCreateRequest{
		Spec: specbody,
		Metadata: metadatabody,
		ApiVersion: "v3",
		Kind: "Node",
	}
	response, err := client.CreateNode(request)
	if err == nil {
        fmt.Printf("%+v\n", response)
    } else {
        fmt.Println(err)
    }
}

            

          

        
       

更多编程语言的SDK代码示例，请参见API Explorer的代码示例页签，可生成自动对应的SDK代码示例。

状态码

状态码	描述
201	表示在指定集群下创建节点的作业下发成功。

错误码

请参见错误码。

父主题：节点管理

上一篇：节点管理

下一篇：获取指定的节点

意见反馈

文档内容是否对您有帮助？

有帮助没帮助

提供反馈

提交成功！非常感谢您的反馈，我们会继续努力做到更好！

系统繁忙，请稍后重试

在使用文档中是否遇到以下问题

内容与产品页面不一致

内容不易理解

缺失示例代码

步骤不可操作

搜不到想要的内容

缺少最佳实践

意见反馈（选填）

0/500

请至少选择一项反馈信息并填写问题反馈

字符长度不能超过500

直接提交取消