
# 创建集群 - CreateAutopilotCluster
#### 功能介绍
该API用于创建一个空集群（即只有控制节点Master，没有工作节点Node）。
![](https://support.huaweicloud.com/api-cce-autopilot/public_sys-resources/note_3.0-zh-cn.png)
- 集群管理的URL格式为：https://Endpoint/uri。其中uri为资源路径，也即API访问的路径。
  
 
#### 接口约束
调用CCE接口创建集群之前，请检查是否已满足如下条件：
- 创建集群之前，您必须先确保已存在**虚拟私有云** ，否则无法创建集群。若您已有虚拟私有云，可重复使用，无需重复创建。虚拟私有云为CCE集群提供一个隔离的、用户自主配置和管理的虚拟网络环境。若您没有虚拟私有云，请先进行创建，详情请参见[创建VPC](https://support.huaweicloud.com/api-vpc/vpc_api01_0001.html)
  
- 创建集群之前，请提前规划好服务网段。容器隧道网络模式的集群在创建之后，无法修改网段参数；vpc网络模式/云原生网络模式的集群在创建后可以新增网段参数/子网参数，不可修改已有网段参数/子网参数，需要重新创建集群才能调整，请谨慎选择。
  
- 请确保已正确创建委托，并确保委托未被删除，委托校验失败将导致集群创建失败。建议登录CCE控制台，如没有创建委托，会提示您创建，如已经创建则无提示。
  
- 默认情况下，一个账户只能创建5个集群（每个Region下），如果您需要创建更多的集群，请申请增加配额。详情请参见[如何申请扩大配额](https://support.huaweicloud.com/cce_faq/cce_faq_00154.html#section2)
  
 
#### 调用方法
请参见[如何调用API](https://support.huaweicloud.com/api-cce-autopilot/cce_02_0099.html)。
#### 授权信息
账号具备所有API的调用权限，如果使用账号下的IAM用户调用当前API，该IAM用户需具备调用API所需的权限。
- 如果使用角色与策略授权，具体权限要求请参见[权限和授权项](https://support.huaweicloud.com/api-cce-autopilot/cce_02_0327.html)。
- 如果使用身份策略授权，需具备如下身份策略权限。
  
  | 授权项                       | 访问级别  | 资源类型（\*为必须） | 条件键                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | 别名                                                                                                                                                   | 依赖的授权项 |
  |:---|:---|:---|:---|:---|:---|
  | cce:cluster:createCluster | Write | cluster \*  | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | - cce:cluster:create   | -      |
  | cce:cluster:createCluster | Write | -           | - g:EnterpriseProjectId   - g:TagKeys   - g:RequestTag/\<tag-key\>   - cce:AssociatePublicIp   - cce:VpcId   - cce:SubnetId    | - cce:cluster:create   | -      |
     
  
 
#### URI
POST /autopilot/v3/projects/{project_id}/clusters
表1路径参数 
| 参数         | 是否必选 | 参数类型   | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|:---|:---|:---|:---|
| project_id | 是    | String | **参数解释：** 项目ID，获取方式请参见[如何获取接口URI中参数](https://support.huaweicloud.com/api-cce-autopilot/cce_02_0271.html)。 **约束限制：** 不涉及 **取值范围：** 账号的项目ID **默认取值：** 不涉及 |
   
#### 请求参数
表2请求Header参数 
| 参数           | 是否必选 | 参数类型   | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
|:---|:---|:---|:---|
| Content-Type | 是    | String | **参数解释：** 消息体的类型（格式），默认为application/json，有其他取值时会在具体接口中专门说明。 **约束限制：** GET方法不做校验 **默认取值：** 不涉及                                                                                                                                                                                 |
| X-Auth-Token | 是    | String | **参数解释：** 调用接口的认证方式分为Token和AK/SK两种，如果您使用的Token方式，此参数为必填，请填写Token的值，获取方式请参见[获取token](https://support.huaweicloud.com/api-cce-autopilot/cce_02_0004.html)。 **约束限制：** 不涉及 **取值范围：** 不涉及 **默认取值：** 不涉及 |
   
表3请求Body参数 
| 参数         | 是否必选 | 参数类型                                                                                         | 描述                                                                  |
|:---|:---|:---|:---|
| kind       | 是    | String                                                                                       | API类型，固定值"Cluster"或"cluster"，该值不可修改。                                |
| apiVersion | 是    | String                                                                                       | API版本，固定值"v3"，该值不可修改。                                               |
| metadata   | 是    | [AutopilotClusterMetadata] object | 集群的基本信息，为集合类的元素类型，包含一组由不同名称定义的属性。                                   |
| spec       | 是    | [AutopilotClusterSpec] object         | spec是集合类的元素类型，您对需要管理的集群对象进行详细描述的主体部分都在spec中给出。CCE通过spec的描述来创建或更新对象。 |
| status     | 否    | [AutopilotClusterStatus] object     | 集合类的元素类型，用于记录对象在系统中的当前状态信息，包含了集群状态和本次创建集群作业的jobID                   |
   
 表4AutopilotClusterMetadata 
| 参数                | 是否必选 | 参数类型                 | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|:---|:---|:---|:---|
| name              | 是    | String               | 集群名称。 命名规则：以小写字母开头，由小写字母、数字、中划线(-)组成，长度范围4-128位，且不能以中划线(-)结尾。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| uid               | 否    | String               | 集群ID，资源唯一标识，创建成功后自动生成，填写无效。在创建包周期集群时，响应体不返回集群ID。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| alias             | 否    | String               | **参数解释：** 集群显示名，用于在 CCE 界面显示，该名称创建后可修改。 **约束限制：** 显示名和其他集群的名称、显示名不可以重复。在创建集群等响应体中，集群显示名alias未配置时将不返回。 **取值范围：** 以中文或英文字符开头，由数字、中文、英文字符、中划线（-）组成，长度范围 4-128位，且不能以中划线（-）开头和结尾。 为空时表示与集群名称name一致。 **默认取值：** 不涉及                                                        |
| annotations       | 否    | Map\<String,String\> | 集群注解，由key/value组成： ``` "annotations": { "key1" : "value1", "key2" : "value2" } ``` 说明： - Annotations不用于标识和选择对象。Annotations中的元数据可以是small或large，structured或unstructured，并且可以包括标签不允许使用的字符。   - 该字段不会被数据库保存，当前仅用于指定集群待安装插件。    |
| labels            | 否    | Map\<String,String\> | 集群标签，key/value对格式。 说明： 该字段值由系统自动生成，用于升级时前端识别集群支持的特性开关，用户指定无效。                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| creationTimestamp | 否    | String               | 集群创建时间                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| updateTimestamp   | 否    | String               | 集群更新时间                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
   
 表5AutopilotClusterSpec 
| 参数                     | 是否必选 | 参数类型                                                                                                             | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|:---|:---|:---|:---|
| category               | 否    | String                                                                                                           | 集群类别。Autopilot集群仅支持Turbo类型。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| type                   | 否    | String                                                                                                           | 集群Master节点架构： - VirtualMachine：Master节点为x86架构服务器                                                                                                                                                                                                                                                                                                                                                                                                        |
| flavor                 | 是    | String                                                                                                           | 集群规格，cce.autopilot.cluster                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| version                | 否    | String                                                                                                           | 集群版本，与Kubernetes社区基线版本保持一致，建议选择最新版本。 在CCE控制台支持创建三种最新版本的集群。可登录CCE控制台创建集群，在"版本"处获取到集群版本。 其它集群版本，当前仍可通过api创建，但后续会逐渐下线，具体下线策略请关注CCE官方公告。 说明： - 若不配置，默认创建最新版本的集群。                                                                                                                                                                                                       |
| platformVersion        | 否    | String                                                                                                           | CCE集群平台版本号，表示集群版本(version)下的内部版本。用于跟踪某一集群版本内的迭代，集群版本内唯一，跨集群版本重新计数。不支持用户指定，集群创建时自动选择对应集群版本的最新平台版本。 platformVersion格式为：cce.X.Y - X: 表示内部特性版本。集群版本中特性或者补丁修复，或者OS支持等变更场景。其值从1开始单调递增。   - Y: 表示内部特性版本的补丁版本。仅用于特性版本上线后的软件包更新，不涉及其他修改。其值从0开始单调递增。           |
| description            | 否    | String                                                                                                           | 集群描述，对于集群使用目的的描述，可根据实际情况自定义，默认为空。集群创建成功后可通过接口[更新指定的集群](https://support.huaweicloud.com/api-cce-autopilot/UpdateAutopilotCluster.html)来做出修改，也可在CCE控制台中对应集群的"集群详情"下的"描述"处进行修改。仅支持utf-8编码。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| customSan              | 否    | Array of strings                                                                                                 | 集群的API Server服务端证书中的自定义SAN（Subject Alternative Name）字段，遵从SSL标准X509定义的格式规范。Autopilot集群暂不支持。 1. 不允许出现同名重复。   2. 格式符合IP和域名格式。    示例: ``` SAN 1: DNS Name=example.com SAN 2: DNS Name=www.example.com SAN 3: DNS Name=example.net SAN 4: IP Address=93.184.216.34 ``` |
| enableSnat             | 否    | Boolean                                                                                                          | 集群是否配置SNAT，仅Autopilot集群创建接口使用和返回。开启后您的集群可以通过NAT网关访问公网，默认使用所选的VPC中已有的NAT网关，否则系统将会为您自动创建一个默认规格的NAT网关并绑定弹性公网IP，自动配置SNAT规则。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| enableSWRImageAccess   | 否    | Boolean                                                                                                          | 集群是否配置镜像访问，仅Autopilot集群创建接口使用和返回。为确保您的集群节点可以从容器镜像服务中拉取镜像，默认使用所选VPC中已有的SWR和OBS终端节点，否则将会为您自动新建SWR和OBS终端节点。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| enableAutopilot        | 否    | Boolean                                                                                                          | 是否为Autopilot集群。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| ipv6enable             | 否    | Boolean                                                                                                          | 集群是否使用IPv6模式。Autopilot集群暂不支持。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| hostNetwork            | 是    | [AutopilotHostNetwork] object                             | 节点网络参数，包含了虚拟私有云VPC和子网的ID信息，而VPC是集群内节点之间的通信依赖，所以是必选的参数集。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| containerNetwork       | 是    | [AutopilotContainerNetwork] object                   | 容器网络参数，包含了容器网络类型和容器网段的信息。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| eniNetwork             | 否    | [AutopilotEniNetwork] object                               | 云原生网络2.0网络配置。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| serviceNetwork         | 否    | [AutopilotServiceNetwork] object                       | 服务网段参数，包含IPv4 CIDR。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| authentication         | 否    | [AutopilotAuthentication] object                       | 集群认证方式相关配置。Autopilot集群暂不支持。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| billingMode            | 否    | Integer                                                                                                          | 集群的计费方式。 - 0: 按需计费    默认为"按需计费"。                                                                                                                                                                                                                                                                                                                                                                                                                      |
| kubernetesSvcIpRange   | 否    | String                                                                                                           | 服务网段参数，kubernetes clusterIP取值范围。创建集群时如若未传参，默认为"10.247.0.0/16"。该参数废弃中，推荐使用新字段serviceNetwork，包含IPv4服务网段。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| clusterTags            | 否    | Array of [AutopilotResourceTag] objects                   | 集群资源标签                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| kubeProxyMode          | 否    | String                                                                                                           | 服务转发模式： - iptables：社区传统的kube-proxy模式，完全以iptables规则的方式来实现service负载均衡。该方式最主要的问题是在服务多的时候产生太多的iptables规则，非增量式更新会引入一定的时延，大规模情况下有明显的性能问题。    说明： 默认使用iptables转发模式。                                                                                                                                                                                                                                            |
| az                     | 否    | String                                                                                                           | 可用区（仅查询返回字段）。 CCE支持的可用区请参考[地区和终端节点](https://console.huaweicloud.com/apiexplorer/#/endpoint/CCE)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| extendParam            | 否    | [AutopilotClusterExtendParam] object               | 集群扩展字段，可配置多可用区集群、专属CCE集群，以及将集群创建在特定的企业项目下等。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| configurationsOverride | 否    | Array of [AutopilotPackageConfiguration] objects | 覆盖集群默认组件配置。Autopilot集群暂不支持。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
   
 表6AutopilotHostNetwork 
| 参数     | 是否必选 | 参数类型   | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
|:---|:---|:---|:---|
| vpc    | 是    | String | 用于创建控制节点的VPC的ID。 获取方法如下： - 方法1：登录虚拟私有云服务的控制台界面，在虚拟私有云的详情页面查找VPC ID。   - 方法2：通过虚拟私有云服务的API接口查询。    链接请参见[查询VPC列表](https://support.huaweicloud.com/api-vpc/vpc_api01_0003.html) |
| subnet | 是    | String | 用于创建控制节点的subnet的网络ID。获取方法如下： - 方法1：登录虚拟私有云服务的控制台界面，单击VPC下的子网，进入子网详情页面，查找网络ID。   - 方法2：通过虚拟私有云服务的查询子网列表接口查询。    链接请参见[查询子网列表](https://support.huaweicloud.com/api-vpc/vpc_subnet01_0003.html)                     |
   
 表7AutopilotContainerNetwork 
| 参数   | 是否必选 | 参数类型   | 描述                                                                                                                                                                                                                                                                                                                 |
|:---|:---|:---|:---|
| mode | 是    | String | 容器网络类型 - eni：云原生网络2.0，深度整合VPC原生ENI弹性网卡能力，采用VPC网段分配容器地址，支持ELB直通容器，享有高性能，创建集群时指定。    |
   
 表8AutopilotEniNetwork 
| 参数      | 是否必选 | 参数类型                                                                                               | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
|:---|:---|:---|:---|
| subnets | 是    | Array of [AutopilotNetworkSubnet] objects | ENI所在子网的IPv4子网ID列表。获取方法如下： - 方法1：登录虚拟私有云服务的控制台界面，单击VPC下的子网，进入子网详情页面，查找IPv4子网ID。   - 方法2：通过虚拟私有云服务的查询子网列表接口查询。    链接请参见[查询子网列表](https://support.huaweicloud.com/api-vpc/vpc_subnet01_0003.html) |
   
 表9AutopilotNetworkSubnet 
| 参数       | 是否必选 | 参数类型   | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
|:---|:---|:---|:---|
| subnetID | 是    | String | 用于创建控制节点和容器的subnet的IPv4子网ID(暂不支持IPv6)。获取方法如下： - 方法1：登录虚拟私有云服务的控制台界面，单击VPC下的子网，进入子网详情页面，查找IPv4子网ID。   - 方法2：通过虚拟私有云服务的查询子网列表接口查询。    链接请参见[查询子网列表](https://support.huaweicloud.com/api-vpc/vpc_subnet01_0003.html) |
   
 表10AutopilotServiceNetwork 
| 参数       | 是否必选 | 参数类型   | 描述                                                               |
|:---|:---|:---|:---|
| IPv4CIDR | 否    | String | kubernetes clusterIP IPv4 CIDR取值范围。创建集群时若未传参，默认为"10.247.0.0/16"。 |
   
 表11AutopilotAuthentication 
| 参数   | 是否必选 | 参数类型   | 描述                  |
|:---|:---|:---|:---|
| mode | 否    | String | 集群认证模式。默认取值为"rbac"。 |
   
 表12AutopilotResourceTag 
| 参数    | 是否必选 | 参数类型   | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|:---|:---|:---|:---|
| key   | 否    | String | Key值。 - 不能为空，最多支持128个字符   - 可用UTF-8格式表示的汉字、字母、数字和空格   - 支持部分特殊字符：_.:/=+-@   - 不能以"_sys_"开头    |
| value | 否    | String | Value值。 - 可以为空但不能缺省，最多支持255个字符   - 可用UTF-8格式表示的汉字、字母、数字和空格   - 支持部分特殊字符：_.:/=+-@                                                                                                                                                              |
   
 表13AutopilotClusterExtendParam 
| 参数                  | 是否必选 | 参数类型   | 描述                                                                                                                                                                                                                                                                             |
|:---|:---|:---|:---|
| enterpriseProjectId | 否    | String | 集群所属的企业项目ID。 说明： - 需要开通企业项目功能后才可配置企业项目。    |
| upgradefrom         | 否    | String | 记录集群通过何种升级方式升级到当前版本。                                                                                                                                                                                                                                                           |
   
 表14AutopilotPackageConfiguration 
| 参数             | 是否必选 | 参数类型                                                                                                       | 描述    |
|:---|:---|:---|:---|
| name           | 否    | String                                                                                                     | 组件名称  |
| configurations | 否    | Array of [AutopilotConfigurationItem] objects | 组件配置项 |
   
 表15AutopilotConfigurationItem 
| 参数    | 是否必选 | 参数类型   | 描述      |
|:---|:---|:---|:---|
| name  | 否    | String | 组件配置项名称 |
| value | 否    | Object | 组件配置项值  |
   
 表16AutopilotClusterStatus 
| 参数           | 是否必选 | 参数类型                                                                                                     | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
|:---|:---|:---|:---|
| phase        | 否    | String                                                                                                   | 集群状态，取值如下 - Available：可用，表示集群处于正常状态。   - Unavailable：不可用，表示集群异常，需手动删除。   - ScalingUp：扩容中，表示集群正处于扩容过程中。   - ScalingDown：缩容中，表示集群正处于缩容过程中。   - Creating：创建中，表示集群正处于创建过程中。   - Deleting：删除中，表示集群正处于删除过程中。   - Upgrading：升级中，表示集群正处于升级过程中。   - Resizing：规格变更中，表示集群正处于变更规格中。   - ResizeFailed：规格变更异常，表示集群变更规格异常。   - RollingBack：回滚中，表示集群正处于回滚过程中。   - RollbackFailed：回滚异常，表示集群回滚异常。   - Hibernating：休眠中，表示集群正处于休眠过程中。   - Hibernation：已休眠，表示集群正处于休眠状态。   - Freezing：冻结中，表示集群正处于冻结过程中。   - Frozen：已冻结，表示集群正处于冻结状态。   - UnFreezing：解冻中，表示集群正处于解冻过程中。   - Awaking：唤醒中，表示集群正处于从休眠状态唤醒的过程中。   - Empty：集群无任何资源（已废弃）   - Error：错误，表示集群资源异常，可尝试手动删除。    |
| jobID        | 否    | String                                                                                                   | 任务ID,集群当前状态关联的任务ID。当前支持: - 创建集群时返回关联的任务ID，可通过任务ID查询创建集群的附属任务信息；   - 删除集群或者删除集群失败时返回关联的任务ID，此字段非空时，可通过任务ID查询删除集群的附属任务信息。    说明： 任务信息具有一定时效性，仅用于短期跟踪任务进度，请勿用于集群状态判断等额外场景。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| reason       | 否    | String                                                                                                   | 集群变为当前状态的原因，在集群在非"Available"状态下时，会返回此参数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| message      | 否    | String                                                                                                   | 集群变为当前状态的原因的详细信息，在集群在非"Available"状态下时，会返回此参数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| endpoints    | 否    | Array of [AutopilotClusterEndpoints] objects | 集群中 kube-apiserver 的访问地址。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| isLocked     | 否    | Boolean                                                                                                  | CBC资源锁定                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| lockScene    | 否    | String                                                                                                   | CBC资源锁定场景                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| lockSource   | 否    | String                                                                                                   | 锁定资源                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| lockSourceId | 否    | String                                                                                                   | 锁定的资源ID                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| deleteOption | 否    | Object                                                                                                   | 删除配置状态（仅删除请求响应包含）                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| deleteStatus | 否    | Object                                                                                                   | 删除状态信息（仅删除请求响应包含）                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
   
 表17AutopilotClusterEndpoints 
| 参数   | 是否必选 | 参数类型   | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|:---|:---|:---|:---|
| url  | 否    | String | 集群中 kube-apiserver 的访问地址                                                                                                                                                                                                                                                                                                                                                                                                               |
| type | 否    | String | 集群访问地址的类型 - Internal：用户子网内访问的地址   - External：公网访问的地址    |
   
#### 响应参数
**状态码：201**
表18响应Body参数 
| 参数         | 参数类型                                                                                          | 描述                                                                  |
|:---|:---|:---|
| kind       | String                                                                                        | API类型，固定值"Cluster"或"cluster"，该值不可修改。                                |
| apiVersion | String                                                                                        | API版本，固定值"v3"，该值不可修改。                                               |
| metadata   | [AutopilotClusterMetadata] object | 集群的基本信息，为集合类的元素类型，包含一组由不同名称定义的属性。                                   |
| spec       | [AutopilotClusterSpec] object         | spec是集合类的元素类型，您对需要管理的集群对象进行详细描述的主体部分都在spec中给出。CCE通过spec的描述来创建或更新对象。 |
| status     | [AutopilotClusterStatus] object     | 集合类的元素类型，用于记录对象在系统中的当前状态信息，包含了集群状态和本次创建集群作业的jobID                   |
   
 表19AutopilotClusterMetadata 
| 参数                | 参数类型                 | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
|:---|:---|:---|
| name              | String               | 集群名称。 命名规则：以小写字母开头，由小写字母、数字、中划线(-)组成，长度范围4-128位，且不能以中划线(-)结尾。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| uid               | String               | 集群ID，资源唯一标识，创建成功后自动生成，填写无效。在创建包周期集群时，响应体不返回集群ID。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| alias             | String               | **参数解释：** 集群显示名，用于在 CCE 界面显示，该名称创建后可修改。 **约束限制：** 显示名和其他集群的名称、显示名不可以重复。在创建集群等响应体中，集群显示名alias未配置时将不返回。 **取值范围：** 以中文或英文字符开头，由数字、中文、英文字符、中划线（-）组成，长度范围 4-128位，且不能以中划线（-）开头和结尾。 为空时表示与集群名称name一致。 **默认取值：** 不涉及                                                                |
| annotations       | Map\<String,String\> | 集群注解，由key/value组成： ``` "annotations": { "key1" : "value1", "key2" : "value2" } ``` 说明： - Annotations不用于标识和选择对象。Annotations中的元数据可以是small或large，structured或unstructured，并且可以包括标签不允许使用的字符。   - 该字段不会被数据库保存，当前仅用于指定集群待安装插件。    |
| labels            | Map\<String,String\> | 集群标签，key/value对格式。 说明： 该字段值由系统自动生成，用于升级时前端识别集群支持的特性开关，用户指定无效。                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| creationTimestamp | String               | 集群创建时间                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| updateTimestamp   | String               | 集群更新时间                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
   
 表20AutopilotClusterSpec 
| 参数                     | 参数类型                                                                                                              | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
|:---|:---|:---|
| category               | String                                                                                                            | 集群类别。Autopilot集群仅支持Turbo类型。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| type                   | String                                                                                                            | 集群Master节点架构： - VirtualMachine：Master节点为x86架构服务器                                                                                                                                                                                                                                                                                                                                                                                               |
| flavor                 | String                                                                                                            | 集群规格，cce.autopilot.cluster                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| version                | String                                                                                                            | 集群版本，与Kubernetes社区基线版本保持一致，建议选择最新版本。 在CCE控制台支持创建三种最新版本的集群。可登录CCE控制台创建集群，在"版本"处获取到集群版本。 其它集群版本，当前仍可通过api创建，但后续会逐渐下线，具体下线策略请关注CCE官方公告。 说明： - 若不配置，默认创建最新版本的集群。                                                                                                                                                                                                     |
| platformVersion        | String                                                                                                            | CCE集群平台版本号，表示集群版本(version)下的内部版本。用于跟踪某一集群版本内的迭代，集群版本内唯一，跨集群版本重新计数。不支持用户指定，集群创建时自动选择对应集群版本的最新平台版本。 platformVersion格式为：cce.X.Y - X: 表示内部特性版本。集群版本中特性或者补丁修复，或者OS支持等变更场景。其值从1开始单调递增。   - Y: 表示内部特性版本的补丁版本。仅用于特性版本上线后的软件包更新，不涉及其他修改。其值从0开始单调递增。              |
| description            | String                                                                                                            | 集群描述，对于集群使用目的的描述，可根据实际情况自定义，默认为空。集群创建成功后可通过接口[更新指定的集群](https://support.huaweicloud.com/api-cce-autopilot/UpdateAutopilotCluster.html)来做出修改，也可在CCE控制台中对应集群的"集群详情"下的"描述"处进行修改。仅支持utf-8编码。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| customSan              | Array of strings                                                                                                  | 集群的API Server服务端证书中的自定义SAN（Subject Alternative Name）字段，遵从SSL标准X509定义的格式规范。Autopilot集群暂不支持。 1. 不允许出现同名重复。   2. 格式符合IP和域名格式。    示例: ``` SAN 1: DNS Name=example.com SAN 2: DNS Name=www.example.com SAN 3: DNS Name=example.net SAN 4: IP Address=93.184.216.34 ``` |
| enableSnat             | Boolean                                                                                                           | 集群是否配置SNAT，仅Autopilot集群创建接口使用和返回。开启后您的集群可以通过NAT网关访问公网，默认使用所选的VPC中已有的NAT网关，否则系统将会为您自动创建一个默认规格的NAT网关并绑定弹性公网IP，自动配置SNAT规则。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| enableSWRImageAccess   | Boolean                                                                                                           | 集群是否配置镜像访问，仅Autopilot集群创建接口使用和返回。为确保您的集群节点可以从容器镜像服务中拉取镜像，默认使用所选VPC中已有的SWR和OBS终端节点，否则将会为您自动新建SWR和OBS终端节点。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| enableAutopilot        | Boolean                                                                                                           | 是否为Autopilot集群。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| ipv6enable             | Boolean                                                                                                           | 集群是否使用IPv6模式。Autopilot集群暂不支持。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| hostNetwork            | [AutopilotHostNetwork] object                             | 节点网络参数，包含了虚拟私有云VPC和子网的ID信息，而VPC是集群内节点之间的通信依赖，所以是必选的参数集。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| containerNetwork       | [AutopilotContainerNetwork] object                   | 容器网络参数，包含了容器网络类型和容器网段的信息。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| eniNetwork             | [AutopilotEniNetwork] object                               | 云原生网络2.0网络配置。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| serviceNetwork         | [AutopilotServiceNetwork] object                       | 服务网段参数，包含IPv4 CIDR。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| authentication         | [AutopilotAuthentication] object                       | 集群认证方式相关配置。Autopilot集群暂不支持。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| billingMode            | Integer                                                                                                           | 集群的计费方式。 - 0: 按需计费    默认为"按需计费"。                                                                                                                                                                                                                                                                                                                                                                                                           |
| kubernetesSvcIpRange   | String                                                                                                            | 服务网段参数，kubernetes clusterIP取值范围。创建集群时如若未传参，默认为"10.247.0.0/16"。该参数废弃中，推荐使用新字段serviceNetwork，包含IPv4服务网段。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| clusterTags            | Array of [AutopilotResourceTag] objects                   | 集群资源标签                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| kubeProxyMode          | String                                                                                                            | 服务转发模式： - iptables：社区传统的kube-proxy模式，完全以iptables规则的方式来实现service负载均衡。该方式最主要的问题是在服务多的时候产生太多的iptables规则，非增量式更新会引入一定的时延，大规模情况下有明显的性能问题。    说明： 默认使用iptables转发模式。                                                                                                                                                                                                                                               |
| az                     | String                                                                                                            | 可用区（仅查询返回字段）。 CCE支持的可用区请参考[地区和终端节点](https://console.huaweicloud.com/apiexplorer/#/endpoint/CCE)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| extendParam            | [AutopilotClusterExtendParam] object               | 集群扩展字段，可配置多可用区集群、专属CCE集群，以及将集群创建在特定的企业项目下等。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| configurationsOverride | Array of [AutopilotPackageConfiguration] objects | 覆盖集群默认组件配置。Autopilot集群暂不支持。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
   
 表21AutopilotHostNetwork 
| 参数     | 参数类型   | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
|:---|:---|:---|
| vpc    | String | 用于创建控制节点的VPC的ID。 获取方法如下： - 方法1：登录虚拟私有云服务的控制台界面，在虚拟私有云的详情页面查找VPC ID。   - 方法2：通过虚拟私有云服务的API接口查询。    链接请参见[查询VPC列表](https://support.huaweicloud.com/api-vpc/vpc_api01_0003.html) |
| subnet | String | 用于创建控制节点的subnet的网络ID。获取方法如下： - 方法1：登录虚拟私有云服务的控制台界面，单击VPC下的子网，进入子网详情页面，查找网络ID。   - 方法2：通过虚拟私有云服务的查询子网列表接口查询。    链接请参见[查询子网列表](https://support.huaweicloud.com/api-vpc/vpc_subnet01_0003.html)                         |
   
 表22AutopilotContainerNetwork 
| 参数   | 参数类型   | 描述                                                                                                                                                                                                                                                                                                                  |
|:---|:---|:---|
| mode | String | 容器网络类型 - eni：云原生网络2.0，深度整合VPC原生ENI弹性网卡能力，采用VPC网段分配容器地址，支持ELB直通容器，享有高性能，创建集群时指定。    |
   
 表23AutopilotEniNetwork 
| 参数      | 参数类型                                                                                                | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
|:---|:---|:---|
| subnets | Array of [AutopilotNetworkSubnet] objects | ENI所在子网的IPv4子网ID列表。获取方法如下： - 方法1：登录虚拟私有云服务的控制台界面，单击VPC下的子网，进入子网详情页面，查找IPv4子网ID。   - 方法2：通过虚拟私有云服务的查询子网列表接口查询。    链接请参见[查询子网列表](https://support.huaweicloud.com/api-vpc/vpc_subnet01_0003.html) |
   
 表24AutopilotNetworkSubnet 
| 参数       | 参数类型   | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
|:---|:---|:---|
| subnetID | String | 用于创建控制节点和容器的subnet的IPv4子网ID(暂不支持IPv6)。获取方法如下： - 方法1：登录虚拟私有云服务的控制台界面，单击VPC下的子网，进入子网详情页面，查找IPv4子网ID。   - 方法2：通过虚拟私有云服务的查询子网列表接口查询。    链接请参见[查询子网列表](https://support.huaweicloud.com/api-vpc/vpc_subnet01_0003.html) |
   
 表25AutopilotServiceNetwork 
| 参数       | 参数类型   | 描述                                                               |
|:---|:---|:---|
| IPv4CIDR | String | kubernetes clusterIP IPv4 CIDR取值范围。创建集群时若未传参，默认为"10.247.0.0/16"。 |
   
 表26AutopilotAuthentication 
| 参数   | 参数类型   | 描述                  |
|:---|:---|:---|
| mode | String | 集群认证模式。默认取值为"rbac"。 |
   
 表27AutopilotResourceTag 
| 参数    | 参数类型   | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|:---|:---|:---|
| key   | String | Key值。 - 不能为空，最多支持128个字符   - 可用UTF-8格式表示的汉字、字母、数字和空格   - 支持部分特殊字符：_.:/=+-@   - 不能以"_sys_"开头    |
| value | String | Value值。 - 可以为空但不能缺省，最多支持255个字符   - 可用UTF-8格式表示的汉字、字母、数字和空格   - 支持部分特殊字符：_.:/=+-@                                                                                                                                                                    |
   
 表28AutopilotClusterExtendParam 
| 参数                  | 参数类型   | 描述                                                                                                                                                                                                                                                                              |
|:---|:---|:---|
| enterpriseProjectId | String | 集群所属的企业项目ID。 说明： - 需要开通企业项目功能后才可配置企业项目。    |
| upgradefrom         | String | 记录集群通过何种升级方式升级到当前版本。                                                                                                                                                                                                                                                            |
   
 表29AutopilotPackageConfiguration 
| 参数             | 参数类型                                                                                                        | 描述    |
|:---|:---|:---|
| name           | String                                                                                                      | 组件名称  |
| configurations | Array of [AutopilotConfigurationItem] objects | 组件配置项 |
   
 表30AutopilotConfigurationItem 
| 参数    | 参数类型   | 描述      |
|:---|:---|:---|
| name  | String | 组件配置项名称 |
| value | Object | 组件配置项值  |
   
 表31AutopilotClusterStatus 
| 参数           | 参数类型                                                                                                      | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|:---|:---|:---|
| phase        | String                                                                                                    | 集群状态，取值如下 - Available：可用，表示集群处于正常状态。   - Unavailable：不可用，表示集群异常，需手动删除。   - ScalingUp：扩容中，表示集群正处于扩容过程中。   - ScalingDown：缩容中，表示集群正处于缩容过程中。   - Creating：创建中，表示集群正处于创建过程中。   - Deleting：删除中，表示集群正处于删除过程中。   - Upgrading：升级中，表示集群正处于升级过程中。   - Resizing：规格变更中，表示集群正处于变更规格中。   - ResizeFailed：规格变更异常，表示集群变更规格异常。   - RollingBack：回滚中，表示集群正处于回滚过程中。   - RollbackFailed：回滚异常，表示集群回滚异常。   - Hibernating：休眠中，表示集群正处于休眠过程中。   - Hibernation：已休眠，表示集群正处于休眠状态。   - Freezing：冻结中，表示集群正处于冻结过程中。   - Frozen：已冻结，表示集群正处于冻结状态。   - UnFreezing：解冻中，表示集群正处于解冻过程中。   - Awaking：唤醒中，表示集群正处于从休眠状态唤醒的过程中。   - Empty：集群无任何资源（已废弃）   - Error：错误，表示集群资源异常，可尝试手动删除。    |
| jobID        | String                                                                                                    | 任务ID,集群当前状态关联的任务ID。当前支持: - 创建集群时返回关联的任务ID，可通过任务ID查询创建集群的附属任务信息；   - 删除集群或者删除集群失败时返回关联的任务ID，此字段非空时，可通过任务ID查询删除集群的附属任务信息。    说明： 任务信息具有一定时效性，仅用于短期跟踪任务进度，请勿用于集群状态判断等额外场景。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| reason       | String                                                                                                    | 集群变为当前状态的原因，在集群在非"Available"状态下时，会返回此参数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| message      | String                                                                                                    | 集群变为当前状态的原因的详细信息，在集群在非"Available"状态下时，会返回此参数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| endpoints    | Array of [AutopilotClusterEndpoints] objects | 集群中 kube-apiserver 的访问地址。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| isLocked     | Boolean                                                                                                   | CBC资源锁定                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| lockScene    | String                                                                                                    | CBC资源锁定场景                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| lockSource   | String                                                                                                    | 锁定资源                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| lockSourceId | String                                                                                                    | 锁定的资源ID                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| deleteOption | Object                                                                                                    | 删除配置状态（仅删除请求响应包含）                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| deleteStatus | Object                                                                                                    | 删除状态信息（仅删除请求响应包含）                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
   
 表32AutopilotClusterEndpoints 
| 参数   | 参数类型   | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|:---|:---|:---|
| url  | String | 集群中 kube-apiserver 的访问地址                                                                                                                                                                                                                                                                                                                                                                                                                     |
| type | String | 集群访问地址的类型 - Internal：用户子网内访问的地址   - External：公网访问的地址    |
   
#### 请求示例
创建一个v1.28版本的Autopilot集群，计费模式为按需计费，。
```
/autopilot/v3/projects/{project_id}/clusters
{
  "kind" : "Cluster",
  "apiVersion" : "v3",
  "metadata" : {
    "name" : "test-cluster-autopilot",
    "annotations" : {
      "cluster.install.addons/install" : "[{\"addonTemplateName\":\"coredns\",\"values\":{\"flavor\":{\"category\":[\"Autopilot\"],\"is_default\":true,\"name\":\"autopilot-flavor1\",\"replicas\":2,\"resources\":[{\"limitsCpu\":1,\"limitsMem\":\"2Gi\",\"name\":\"coredns\",\"requestsCpu\":1,\"requestsMem\":\"2Gi\"}]}}},{\"addonTemplateName\":\"metrics-server\",\"values\":{\"flavor\":{\"category\":[\"Autopilot\"],\"description\":\"custom resources in autopilot cluster\",\"is_default\":true,\"name\":\"autopilot-flavor1\",\"replicas\":2,\"resources\":[{\"limitsCpu\":1,\"limitsMem\":\"2Gi\",\"name\":\"metrics-server\",\"requestsCpu\":1,\"requestsMem\":\"2Gi\"}]}}}]"
    }
  },
  "spec" : {
    "category" : "Turbo",
    "flavor" : "cce.autopilot.cluster",
    "type" : "VirtualMachine",
    "version" : "v1.28",
    "hostNetwork" : {
      "vpc" : "c6549063-d459-4ae1-9550-b5fec6741b0f",
      "subnet" : "xxxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
    },
    "extendParam" : {
      "enterpriseProjectId" : "0"
    },
    "containerNetwork" : {
      "mode" : "eni"
    },
    "description" : "",
    "billingMode" : 0,
    "eniNetwork" : {
      "subnets" : [ {
        "subnetID" : "186f9322-50c5-4e5a-91e3-47da86959afc"
      } ]
    },
    "enableSWRImageAccess" : true,
    "enableSnat" : true,
    "serviceNetwork" : {
      "IPv4CIDR" : "10.247.0.0/16"
    }
  }
}
```
#### 响应示例
**状态码：201**
表示创建集群作业下发成功。
```
{
  "kind" : "Cluster",
  "apiVersion" : "v3",
  "metadata" : {
    "name" : "test-cluster-autopilot",
    "uid" : "e18f8b25-2270-11ef-a160-0255ac100100",
    "creationTimestamp" : "2024-06-04 12:49:28.773718231 +0000 UTC",
    "updateTimestamp" : "2024-06-04 12:49:28.773718305 +0000 UTC",
    "annotations" : {
      "jobid" : "e1c49157-2270-11ef-a160-0255ac100100",
      "resourceJobId" : "e18fa26f-2270-11ef-a160-0255ac100100"
    }
  },
  "spec" : {
    "category" : "Turbo",
    "type" : "VirtualMachine",
    "flavor" : "cce.autopilot.cluster",
    "version" : "v1.28",
    "platformVersion" : "cce.4.0",
    "hostNetwork" : {
      "vpc" : "c6549063-d459-4ae1-9550-b5fec6741b0f",
      "subnet" : "3b18c2d5-b352-4f59-b421-c2d2d48a1333"
    },
    "containerNetwork" : {
      "mode" : "eni"
    },
    "eniNetwork" : {
      "subnets" : [ {
        "subnetID" : "186f9322-50c5-4e5a-91e3-47da86959afc"
      } ]
    },
    "serviceNetwork" : {
      "IPv4CIDR" : "10.247.0.0/16"
    },
    "authentication" : {
      "mode" : "rbac"
    },
    "billingMode" : 0,
    "kubernetesSvcIpRange" : "10.247.0.0/16",
    "kubeProxyMode" : "iptables",
    "extendParam" : {
      "enterpriseProjectId" : "0"
    },
    "enableSWRImageAccess" : true,
    "enableSnat" : true
  },
  "status" : {
    "phase" : "Creating",
    "jobID" : "e1c49157-2270-11ef-a160-0255ac100100"
  }
}
```
#### SDK代码示例
SDK代码示例如下。
- [Java]
  创建一个v1.28版本的Autopilot集群，计费模式为按需计费，。
  ```
  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 java.util.List;
  import java.util.ArrayList;
  import java.util.Map;
  import java.util.HashMap;
  public class CreateAutopilotClusterSolution {
      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();
          CreateAutopilotClusterRequest request = new CreateAutopilotClusterRequest();
          AutopilotCluster body = new AutopilotCluster();
          AutopilotClusterExtendParam extendParamSpec = new AutopilotClusterExtendParam();
          extendParamSpec.withEnterpriseProjectId("0");
          AutopilotServiceNetwork serviceNetworkSpec = new AutopilotServiceNetwork();
          serviceNetworkSpec.withIpv4CIDR("10.247.0.0/16");
          List<AutopilotNetworkSubnet> listEniNetworkSubnets = new ArrayList<>();
          listEniNetworkSubnets.add(
              new AutopilotNetworkSubnet()
                  .withSubnetID("186f9322-50c5-4e5a-91e3-47da86959afc")
          );
          AutopilotEniNetwork eniNetworkSpec = new AutopilotEniNetwork();
          eniNetworkSpec.withSubnets(listEniNetworkSubnets);
          AutopilotContainerNetwork containerNetworkSpec = new AutopilotContainerNetwork();
          containerNetworkSpec.withMode(AutopilotContainerNetwork.ModeEnum.fromValue("eni"));
          AutopilotHostNetwork hostNetworkSpec = new AutopilotHostNetwork();
          hostNetworkSpec.withVpc("c6549063-d459-4ae1-9550-b5fec6741b0f")
              .withSubnet("xxxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx");
          AutopilotClusterSpec specbody = new AutopilotClusterSpec();
          specbody.withCategory(AutopilotClusterSpec.CategoryEnum.fromValue("Turbo"))
              .withType(AutopilotClusterSpec.TypeEnum.fromValue("VirtualMachine"))
              .withFlavor("cce.autopilot.cluster")
              .withVersion("v1.28")
              .withDescription("")
              .withEnableSnat(true)
              .withEnableSWRImageAccess(true)
              .withHostNetwork(hostNetworkSpec)
              .withContainerNetwork(containerNetworkSpec)
              .withEniNetwork(eniNetworkSpec)
              .withServiceNetwork(serviceNetworkSpec)
              .withBillingMode(0)
              .withExtendParam(extendParamSpec);
          Map<String, String> listMetadataAnnotations = new HashMap<>();
          listMetadataAnnotations.put("cluster.install.addons/install", "[{"addonTemplateName":"coredns","values":{"flavor":{"category":["Autopilot"],"is_default":true,"name":"autopilot-flavor1","replicas":2,"resources":[{"limitsCpu":1,"limitsMem":"2Gi","name":"coredns","requestsCpu":1,"requestsMem":"2Gi"}]}}},{"addonTemplateName":"metrics-server","values":{"flavor":{"category":["Autopilot"],"description":"custom resources in autopilot cluster","is_default":true,"name":"autopilot-flavor1","replicas":2,"resources":[{"limitsCpu":1,"limitsMem":"2Gi","name":"metrics-server","requestsCpu":1,"requestsMem":"2Gi"}]}}}]");
          AutopilotClusterMetadata metadatabody = new AutopilotClusterMetadata();
          metadatabody.withName("test-cluster-autopilot")
              .withAnnotations(listMetadataAnnotations);
          body.withSpec(specbody);
          body.withMetadata(metadatabody);
          body.withApiVersion("v3");
          body.withKind("Cluster");
          request.withBody(body);
          try {
              CreateAutopilotClusterResponse response = client.createAutopilotCluster(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());
          }
      }
  }
  ```
- [Python]
  创建一个v1.28版本的Autopilot集群，计费模式为按需计费，。
  ```
  # 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 = CreateAutopilotClusterRequest()
          extendParamSpec = AutopilotClusterExtendParam(
              enterprise_project_id="0"
          )
          serviceNetworkSpec = AutopilotServiceNetwork(
              i_pv4_cidr="10.247.0.0/16"
          )
          listSubnetsEniNetwork = [
              AutopilotNetworkSubnet(
                  subnet_id="186f9322-50c5-4e5a-91e3-47da86959afc"
              )
          ]
          eniNetworkSpec = AutopilotEniNetwork(
              subnets=listSubnetsEniNetwork
          )
          containerNetworkSpec = AutopilotContainerNetwork(
              mode="eni"
          )
          hostNetworkSpec = AutopilotHostNetwork(
              vpc="c6549063-d459-4ae1-9550-b5fec6741b0f",
              subnet="xxxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
          )
          specbody = AutopilotClusterSpec(
              category="Turbo",
              type="VirtualMachine",
              flavor="cce.autopilot.cluster",
              version="v1.28",
              description="",
              enable_snat=True,
              enable_swr_image_access=True,
              host_network=hostNetworkSpec,
              container_network=containerNetworkSpec,
              eni_network=eniNetworkSpec,
              service_network=serviceNetworkSpec,
              billing_mode=0,
              extend_param=extendParamSpec
          )
          listAnnotationsMetadata = {
              "cluster.install.addons/install": "[{"addonTemplateName":"coredns","values":{"flavor":{"category":["Autopilot"],"is_default":true,"name":"autopilot-flavor1","replicas":2,"resources":[{"limitsCpu":1,"limitsMem":"2Gi","name":"coredns","requestsCpu":1,"requestsMem":"2Gi"}]}}},{"addonTemplateName":"metrics-server","values":{"flavor":{"category":["Autopilot"],"description":"custom resources in autopilot cluster","is_default":true,"name":"autopilot-flavor1","replicas":2,"resources":[{"limitsCpu":1,"limitsMem":"2Gi","name":"metrics-server","requestsCpu":1,"requestsMem":"2Gi"}]}}}]"
          }
          metadatabody = AutopilotClusterMetadata(
              name="test-cluster-autopilot",
              annotations=listAnnotationsMetadata
          )
          request.body = AutopilotCluster(
              spec=specbody,
              metadata=metadatabody,
              api_version="v3",
              kind="Cluster"
          )
          response = client.create_autopilot_cluster(request)
          print(response)
      except exceptions.ClientRequestException as e:
          print(e.status_code)
          print(e.request_id)
          print(e.error_code)
          print(e.error_msg)
  ```
- [Go]
  创建一个v1.28版本的Autopilot集群，计费模式为按需计费，。
  ```
  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.CreateAutopilotClusterRequest{}
  enterpriseProjectIdExtendParam:= "0"
  extendParamSpec := &model.AutopilotClusterExtendParam{
  EnterpriseProjectId: &enterpriseProjectIdExtendParam,
  }
  iPv4CIDRServiceNetwork:= "10.247.0.0/16"
  serviceNetworkSpec := &model.AutopilotServiceNetwork{
  IPv4CIDR: &iPv4CIDRServiceNetwork,
  }
  var listSubnetsEniNetwork = []model.AutopilotNetworkSubnet{
          {
              SubnetID: "186f9322-50c5-4e5a-91e3-47da86959afc",
          },
      }
  eniNetworkSpec := &model.AutopilotEniNetwork{
  Subnets: listSubnetsEniNetwork,
  }
  containerNetworkSpec := &model.AutopilotContainerNetwork{
  Mode: model.GetAutopilotContainerNetworkModeEnum().ENI,
  }
  hostNetworkSpec := &model.AutopilotHostNetwork{
  Vpc: "c6549063-d459-4ae1-9550-b5fec6741b0f",
  Subnet: "xxxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  }
  categorySpec:= model.GetAutopilotClusterSpecCategoryEnum().TURBO
  typeSpec:= model.GetAutopilotClusterSpecTypeEnum().VIRTUAL_MACHINE
  versionSpec:= "v1.28"
  descriptionSpec:= ""
  enableSnatSpec:= true
  enableSWRImageAccessSpec:= true
  billingModeSpec:= int32(0)
  specbody := &model.AutopilotClusterSpec{
  Category: &categorySpec,
  Type: &typeSpec,
  Flavor: "cce.autopilot.cluster",
  Version: &versionSpec,
  Description: &descriptionSpec,
  EnableSnat: &enableSnatSpec,
  EnableSWRImageAccess: &enableSWRImageAccessSpec,
  HostNetwork: hostNetworkSpec,
  ContainerNetwork: containerNetworkSpec,
  EniNetwork: eniNetworkSpec,
  ServiceNetwork: serviceNetworkSpec,
  BillingMode: &billingModeSpec,
  ExtendParam: extendParamSpec,
  }
  var listAnnotationsMetadata = map[string]string{
          "cluster.install.addons/install": "[{"addonTemplateName":"coredns","values":{"flavor":{"category":["Autopilot"],"is_default":true,"name":"autopilot-flavor1","replicas":2,"resources":[{"limitsCpu":1,"limitsMem":"2Gi","name":"coredns","requestsCpu":1,"requestsMem":"2Gi"}]}}},{"addonTemplateName":"metrics-server","values":{"flavor":{"category":["Autopilot"],"description":"custom resources in autopilot cluster","is_default":true,"name":"autopilot-flavor1","replicas":2,"resources":[{"limitsCpu":1,"limitsMem":"2Gi","name":"metrics-server","requestsCpu":1,"requestsMem":"2Gi"}]}}}]",
      }
  metadatabody := &model.AutopilotClusterMetadata{
  Name: "test-cluster-autopilot",
  Annotations: listAnnotationsMetadata,
  }
  request.Body = &model.AutopilotCluster{
  Spec: specbody,
  Metadata: metadatabody,
  ApiVersion: "v3",
  Kind: "Cluster",
  }
  response, err := client.CreateAutopilotCluster(request)
  if err == nil {
          fmt.Printf("%+v\n", response)
      } else {
          fmt.Println(err)
      }
  }
  ```
- [更多]
  更多编程语言的SDK代码示例，请参见[API Explorer](https://console.huaweicloud.com/apiexplorer/#/openapi/CCE/sdk?api=CreateAutopilotCluster)的代码示例页签，可生成自动对应的SDK代码示例。
#### 状态码
| 状态码 | 描述            |
|:---|:---|
| 201 | 表示创建集群作业下发成功。 |
   
#### 错误码
请参见[错误码](https://support.huaweicloud.com/api-cce-autopilot/ErrorCode.html)。
