# NodeClusterService
> 边缘节点集群管理服务

---

## checkNodeClusterDNSChanges
> 检查集群的DNS是否有变化

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/checkNodeClusterDNSChanges`
- RPC：`rpc checkNodeClusterDNSChanges (CheckNodeClusterDNSChangesRequest) returns (CheckNodeClusterDNSChangesResponse);`

**请求对象 (`CheckNodeClusterDNSChangesRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID"
}
```

**响应对象 (`CheckNodeClusterDNSChangesResponse`)**

```json
{
  "isChanged": "bool"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/checkNodeClusterDNSChanges" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## checkNodeClusterDNSName
> 检查集群域名是否已经被使用

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/checkNodeClusterDNSName`
- RPC：`rpc checkNodeClusterDNSName (CheckNodeClusterDNSNameRequest) returns (CheckNodeClusterDNSNameResponse);`

**请求对象 (`CheckNodeClusterDNSNameRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID",
  "dnsName": "string"
}
```

**响应对象 (`CheckNodeClusterDNSNameResponse`)**

```json
{
  "isUsed": "bool"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/checkNodeClusterDNSName" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## checkPortIsUsingInNodeCluster
> 检查端口是否已经被使用

- 角色：`admin`, `user`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/checkPortIsUsingInNodeCluster`
- RPC：`rpc checkPortIsUsingInNodeCluster (CheckPortIsUsingInNodeClusterRequest) returns (CheckPortIsUsingInNodeClusterResponse);`

**请求对象 (`CheckPortIsUsingInNodeClusterRequest`)**

```json
{
  "port": "int32",
  "nodeClusterId": "int64 // 集群ID",
  "excludeServerId": "int64",
  "excludeProtocol": "string",
  "protocolFamily": "string"
}
```

**响应对象 (`CheckPortIsUsingInNodeClusterResponse`)**

```json
{
  "isUsing": "bool"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/checkPortIsUsingInNodeCluster" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## countAllEnabledNodeClusters
> 计算所有集群数量

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/countAllEnabledNodeClusters`
- RPC：`rpc countAllEnabledNodeClusters (CountAllEnabledNodeClustersRequest) returns (RPCCountResponse);`

**请求对象 (`CountAllEnabledNodeClustersRequest`)**

```json
{
  "keyword": "string // 关键词"
}
```

**响应对象 (`RPCCountResponse`)**

```json
{
  "count": "int64 // 数量"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/countAllEnabledNodeClusters" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## countAllEnabledNodeClustersWithDNSDomainId
> 计算使用某个DNS域名的集群数量

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/countAllEnabledNodeClustersWithDNSDomainId`
- RPC：`rpc countAllEnabledNodeClustersWithDNSDomainId (CountAllEnabledNodeClustersWithDNSDomainIdRequest) returns (RPCCountResponse);`

**请求对象 (`CountAllEnabledNodeClustersWithDNSDomainIdRequest`)**

```json
{
  "dnsDomainId": "int64"
}
```

**响应对象 (`RPCCountResponse`)**

```json
{
  "count": "int64 // 数量"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/countAllEnabledNodeClustersWithDNSDomainId" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## countAllEnabledNodeClustersWithDNSProviderId
> 计算使用某个DNS服务商的集群数量

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/countAllEnabledNodeClustersWithDNSProviderId`
- RPC：`rpc countAllEnabledNodeClustersWithDNSProviderId (CountAllEnabledNodeClustersWithDNSProviderIdRequest) returns (RPCCountResponse);`

**请求对象 (`CountAllEnabledNodeClustersWithDNSProviderIdRequest`)**

```json
{
  "dnsProviderId": "int64"
}
```

**响应对象 (`RPCCountResponse`)**

```json
{
  "count": "int64 // 数量"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/countAllEnabledNodeClustersWithDNSProviderId" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## countAllEnabledNodeClustersWithHTTPCachePolicyId
> 计算使用某个缓存策略的集群数量

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/countAllEnabledNodeClustersWithHTTPCachePolicyId`
- RPC：`rpc countAllEnabledNodeClustersWithHTTPCachePolicyId (CountAllEnabledNodeClustersWithHTTPCachePolicyIdRequest) returns (RPCCountResponse);`

**请求对象 (`CountAllEnabledNodeClustersWithHTTPCachePolicyIdRequest`)**

```json
{
  "httpCachePolicyId": "int64"
}
```

**响应对象 (`RPCCountResponse`)**

```json
{
  "count": "int64 // 数量"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/countAllEnabledNodeClustersWithHTTPCachePolicyId" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## countAllEnabledNodeClustersWithHTTPFirewallPolicyId
> 计算使用某个WAF策略的集群数量

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/countAllEnabledNodeClustersWithHTTPFirewallPolicyId`
- RPC：`rpc countAllEnabledNodeClustersWithHTTPFirewallPolicyId (CountAllEnabledNodeClustersWithHTTPFirewallPolicyIdRequest) returns (RPCCountResponse);`

**请求对象 (`CountAllEnabledNodeClustersWithHTTPFirewallPolicyIdRequest`)**

```json
{
  "httpFirewallPolicyId": "int64"
}
```

**响应对象 (`RPCCountResponse`)**

```json
{
  "count": "int64 // 数量"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/countAllEnabledNodeClustersWithHTTPFirewallPolicyId" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## countAllEnabledNodeClustersWithNodeGrantId
> 计算使用某个认证的集群数量

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/countAllEnabledNodeClustersWithNodeGrantId`
- RPC：`rpc countAllEnabledNodeClustersWithNodeGrantId (CountAllEnabledNodeClustersWithNodeGrantIdRequest) returns (RPCCountResponse);`

**请求对象 (`CountAllEnabledNodeClustersWithNodeGrantIdRequest`)**

```json
{
  "nodeGrantId": "int64"
}
```

**响应对象 (`RPCCountResponse`)**

```json
{
  "count": "int64 // 数量"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/countAllEnabledNodeClustersWithNodeGrantId" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## createNodeCluster
> 创建集群

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/createNodeCluster`
- RPC：`rpc createNodeCluster (CreateNodeClusterRequest) returns (CreateNodeClusterResponse);`

**请求对象 (`CreateNodeClusterRequest`)**

```json
{
  "name": "string // 名称",
  "nodeGrantId": "int64",
  "installDir": "string",
  "dnsDomainId": "int64",
  "dnsName": "string",
  "dnsTTL": "int32",
  "httpCachePolicyId": "int64",
  "httpFirewallPolicyId": "int64",
  "systemServicesJSON": "bytes // 系统服务设置",
  "globalServerConfigJSON": "bytes // 服务全局设置",
  "autoInstallNftables": "bool // 自动安装nftables",
  "autoSystemTuning": "bool // 是否自动调节系统参数",
  "autoTrimDisks": "bool // 是否自动TRIM硬盘",
  "maxConcurrentReads": "int32 // 最大并发读",
  "maxConcurrentWrites": "int32 // 最大并发写"
}
```

**响应对象 (`CreateNodeClusterResponse`)**

```json
{
  "nodeClusterId": "int64 // 集群ID"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/createNodeCluster" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## deleteNodeCluster
> 删除集群

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/deleteNodeCluster`
- RPC：`rpc deleteNodeCluster (DeleteNodeClusterRequest) returns (RPCSuccess);`

**请求对象 (`DeleteNodeClusterRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/deleteNodeCluster" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## executeNodeClusterHealthCheck
> 执行健康检查

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/executeNodeClusterHealthCheck`
- RPC：`rpc executeNodeClusterHealthCheck (ExecuteNodeClusterHealthCheckRequest) returns (ExecuteNodeClusterHealthCheckResponse);`

**请求对象 (`ExecuteNodeClusterHealthCheckRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID"
}
```

**响应对象 (`ExecuteNodeClusterHealthCheckResponse`)**

```json
{
  "results": "[]Result",
  "node": "Node",
  "nodeAddr": "string",
  "isOk": "bool",
  "error": "string",
  "costMs": "float"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/executeNodeClusterHealthCheck" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findAPINodesWithNodeCluster
> 查找集群的API节点信息

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/findAPINodesWithNodeCluster`
- RPC：`rpc findAPINodesWithNodeCluster (FindAPINodesWithNodeClusterRequest) returns (FindAPINodesWithNodeClusterResponse);`

**请求对象 (`FindAPINodesWithNodeClusterRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID"
}
```

**响应对象 (`FindAPINodesWithNodeClusterResponse`)**

```json
{
  "useAllAPINodes": "bool",
  "apiNodes": "[]APINode"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/findAPINodesWithNodeCluster" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findAllEnabledNodeClusters
> 获取所有可用集群

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/findAllEnabledNodeClusters`
- RPC：`rpc findAllEnabledNodeClusters (FindAllEnabledNodeClustersRequest) returns (FindAllEnabledNodeClustersResponse);`

**请求对象 (`FindAllEnabledNodeClustersRequest`)**

```json
{}
```

**响应对象 (`FindAllEnabledNodeClustersResponse`)**

```json
{
  "nodeClusters": "[]NodeCluster"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/findAllEnabledNodeClusters" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findAllEnabledNodeClustersWithDNSDomainId
> 查找使用某个域名的所有集群

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/findAllEnabledNodeClustersWithDNSDomainId`
- RPC：`rpc findAllEnabledNodeClustersWithDNSDomainId (FindAllEnabledNodeClustersWithDNSDomainIdRequest) returns (FindAllEnabledNodeClustersWithDNSDomainIdResponse);`

**请求对象 (`FindAllEnabledNodeClustersWithDNSDomainIdRequest`)**

```json
{
  "dnsDomainId": "int64"
}
```

**响应对象 (`FindAllEnabledNodeClustersWithDNSDomainIdResponse`)**

```json
{
  "nodeClusters": "[]NodeCluster"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/findAllEnabledNodeClustersWithDNSDomainId" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findAllEnabledNodeClustersWithHTTPCachePolicyId
> 查找使用缓存策略的所有集群

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/findAllEnabledNodeClustersWithHTTPCachePolicyId`
- RPC：`rpc findAllEnabledNodeClustersWithHTTPCachePolicyId (FindAllEnabledNodeClustersWithHTTPCachePolicyIdRequest) returns (FindAllEnabledNodeClustersWithHTTPCachePolicyIdResponse);`

**请求对象 (`FindAllEnabledNodeClustersWithHTTPCachePolicyIdRequest`)**

```json
{
  "httpCachePolicyId": "int64"
}
```

**响应对象 (`FindAllEnabledNodeClustersWithHTTPCachePolicyIdResponse`)**

```json
{
  "nodeClusters": "[]NodeCluster"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/findAllEnabledNodeClustersWithHTTPCachePolicyId" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findAllEnabledNodeClustersWithHTTPFirewallPolicyId
> 查找使用某个WAF策略的所有集群

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/findAllEnabledNodeClustersWithHTTPFirewallPolicyId`
- RPC：`rpc findAllEnabledNodeClustersWithHTTPFirewallPolicyId (FindAllEnabledNodeClustersWithHTTPFirewallPolicyIdRequest) returns (FindAllEnabledNodeClustersWithHTTPFirewallPolicyIdResponse);`

**请求对象 (`FindAllEnabledNodeClustersWithHTTPFirewallPolicyIdRequest`)**

```json
{
  "httpFirewallPolicyId": "int64"
}
```

**响应对象 (`FindAllEnabledNodeClustersWithHTTPFirewallPolicyIdResponse`)**

```json
{
  "nodeClusters": "[]NodeCluster"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/findAllEnabledNodeClustersWithHTTPFirewallPolicyId" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findAllEnabledNodeClustersWithNodeGrantId
> 查找使用某个认证的所有集群

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/findAllEnabledNodeClustersWithNodeGrantId`
- RPC：`rpc findAllEnabledNodeClustersWithNodeGrantId (FindAllEnabledNodeClustersWithNodeGrantIdRequest) returns (FindAllEnabledNodeClustersWithNodeGrantIdResponse);`

**请求对象 (`FindAllEnabledNodeClustersWithNodeGrantIdRequest`)**

```json
{
  "nodeGrantId": "int64"
}
```

**响应对象 (`FindAllEnabledNodeClustersWithNodeGrantIdResponse`)**

```json
{
  "nodeClusters": "[]NodeCluster"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/findAllEnabledNodeClustersWithNodeGrantId" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findEnabledNodeCluster
> 查找单个集群信息

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/findEnabledNodeCluster`
- RPC：`rpc findEnabledNodeCluster (FindEnabledNodeClusterRequest) returns (FindEnabledNodeClusterResponse);`

**请求对象 (`FindEnabledNodeClusterRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID",
  "useGlobal": "bool // 是否使用全局配置，如果是则根据当前集群是否使用全局判断返回对应 NodeCluster"
}
```

**响应对象 (`FindEnabledNodeClusterResponse`)**

```json
{
  "nodeCluster": "NodeCluster"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/findEnabledNodeCluster" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findEnabledNodeClusterConfigInfo
> 取得集群的配置概要信息

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/findEnabledNodeClusterConfigInfo`
- RPC：`rpc findEnabledNodeClusterConfigInfo (FindEnabledNodeClusterConfigInfoRequest) returns (FindEnabledNodeClusterConfigInfoResponse);`

**请求对象 (`FindEnabledNodeClusterConfigInfoRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID"
}
```

**响应对象 (`FindEnabledNodeClusterConfigInfoResponse`)**

```json
{
  "healthCheckIsOn": "bool // 启用了健康检查",
  "hasFirewallActions": "bool // 有防火墙动作设置",
  "hasThresholds": "bool // 有节点阈值设置",
  "hasMessageReceivers": "bool // 已设置消息通知接收人",
  "isTOAEnabled": "bool // 启用了TOA",
  "hasMetricItems": "bool // 有指标统计设置",
  "webPIsOn": "bool // 是否定义了WebP策略",
  "uamIsOn": "bool // 是否定义了UAM策略",
  "httpCCIsOn": "bool // 是否定义了CC策略",
  "hasSystemServices": "bool // 启用了系统服务",
  "hasDDoSProtection": "bool // 启用了DDoS防护",
  "hasHTTPPagesPolicy": "bool // 是否设置了自定义页面策略",
  "http3IsOn": "bool // 是否启用HTTP3",
  "hasNetworkSecurityPolicy": "bool // 设置了网络安全策略"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/findEnabledNodeClusterConfigInfo" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findEnabledNodeClusterDNS
> 查找集群的DNS配置

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/findEnabledNodeClusterDNS`
- RPC：`rpc findEnabledNodeClusterDNS (FindEnabledNodeClusterDNSRequest) returns (FindEnabledNodeClusterDNSResponse);`

**请求对象 (`FindEnabledNodeClusterDNSRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID"
}
```

**响应对象 (`FindEnabledNodeClusterDNSResponse`)**

```json
{
  "name": "string // 名称",
  "domain": "DNSDomain",
  "provider": "DNSProvider",
  "defaultRoute": "string",
  "nodesAutoSync": "bool",
  "serversAutoSync": "bool",
  "cnameRecords": "[]string",
  "ttl": "int32",
  "cnameAsDomain": "bool",
  "includingLnNodes": "bool"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/findEnabledNodeClusterDNS" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findEnabledNodeClusterHTTPCCPolicy
> 读取集群的HTTP CC策略

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/findEnabledNodeClusterHTTPCCPolicy`
- RPC：`rpc findEnabledNodeClusterHTTPCCPolicy(FindEnabledNodeClusterHTTPCCPolicyRequest) returns (FindEnabledNodeClusterHTTPCCPolicyResponse);`

**请求对象 (`FindEnabledNodeClusterHTTPCCPolicyRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID"
}
```

**响应对象 (`FindEnabledNodeClusterHTTPCCPolicyResponse`)**

```json
{
  "httpCCPolicyJSON": "bytes"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/findEnabledNodeClusterHTTPCCPolicy" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findEnabledNodeClusterTOA
> 查找集群的TOA配置

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/findEnabledNodeClusterTOA`
- RPC：`rpc findEnabledNodeClusterTOA (FindEnabledNodeClusterTOARequest) returns (FindEnabledNodeClusterTOAResponse);`

**请求对象 (`FindEnabledNodeClusterTOARequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID"
}
```

**响应对象 (`FindEnabledNodeClusterTOAResponse`)**

```json
{
  "toaJSON": "bytes"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/findEnabledNodeClusterTOA" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findEnabledNodeClusterUAMPolicy
> 读取集群的UAM策略

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/findEnabledNodeClusterUAMPolicy`
- RPC：`rpc findEnabledNodeClusterUAMPolicy(FindEnabledNodeClusterUAMPolicyRequest) returns (FindEnabledNodeClusterUAMPolicyResponse);`

**请求对象 (`FindEnabledNodeClusterUAMPolicyRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID"
}
```

**响应对象 (`FindEnabledNodeClusterUAMPolicyResponse`)**

```json
{
  "uamPolicyJSON": "bytes"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/findEnabledNodeClusterUAMPolicy" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findEnabledNodeClusterWebPPolicy
> 读取集群WebP策略

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/findEnabledNodeClusterWebPPolicy`
- RPC：`rpc findEnabledNodeClusterWebPPolicy(FindEnabledNodeClusterWebPPolicyRequest) returns (FindEnabledNodeClusterWebPPolicyResponse);`

**请求对象 (`FindEnabledNodeClusterWebPPolicyRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID"
}
```

**响应对象 (`FindEnabledNodeClusterWebPPolicyResponse`)**

```json
{
  "webpPolicyJSON": "bytes"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/findEnabledNodeClusterWebPPolicy" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findFreePortInNodeCluster
> 获取集群中可以使用的端口

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/findFreePortInNodeCluster`
- RPC：`rpc findFreePortInNodeCluster (FindFreePortInNodeClusterRequest) returns (FindFreePortInNodeClusterResponse);`

**请求对象 (`FindFreePortInNodeClusterRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID",
  "protocolFamily": "string"
}
```

**响应对象 (`FindFreePortInNodeClusterResponse`)**

```json
{
  "port": "int32"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/findFreePortInNodeCluster" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findLatestNodeClusters
> 查找最近访问的集群

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/findLatestNodeClusters`
- RPC：`rpc findLatestNodeClusters (FindLatestNodeClustersRequest) returns (FindLatestNodeClustersResponse);`

**请求对象 (`FindLatestNodeClustersRequest`)**

```json
{
  "size": "int64 // 数量，通常不能小于0"
}
```

**响应对象 (`FindLatestNodeClustersResponse`)**

```json
{
  "nodeClusters": "[]NodeCluster"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/findLatestNodeClusters" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findNodeClusterDDoSProtection
> 获取集群的DDoS设置

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/findNodeClusterDDoSProtection`
- RPC：`rpc findNodeClusterDDoSProtection(FindNodeClusterDDoSProtectionRequest) returns (FindNodeClusterDDoSProtectionResponse);`

**请求对象 (`FindNodeClusterDDoSProtectionRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID"
}
```

**响应对象 (`FindNodeClusterDDoSProtectionResponse`)**

```json
{
  "ddosProtectionJSON": "bytes"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/findNodeClusterDDoSProtection" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findNodeClusterGlobalServerConfig
> 获取集群的全局服务设置

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/findNodeClusterGlobalServerConfig`
- RPC：`rpc findNodeClusterGlobalServerConfig(FindNodeClusterGlobalServerConfigRequest) returns (FindNodeClusterGlobalServerConfigResponse);`

**请求对象 (`FindNodeClusterGlobalServerConfigRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID"
}
```

**响应对象 (`FindNodeClusterGlobalServerConfigResponse`)**

```json
{
  "globalServerConfigJSON": "bytes"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/findNodeClusterGlobalServerConfig" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findNodeClusterHTTP3Policy
> 获取集群的HTTP3设置

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/findNodeClusterHTTP3Policy`
- RPC：`rpc findNodeClusterHTTP3Policy(FindNodeClusterHTTP3PolicyRequest) returns (FindNodeClusterHTTP3PolicyResponse);`

**请求对象 (`FindNodeClusterHTTP3PolicyRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID"
}
```

**响应对象 (`FindNodeClusterHTTP3PolicyResponse`)**

```json
{
  "http3PolicyJSON": "bytes // HTTP3策略配置"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/findNodeClusterHTTP3Policy" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findNodeClusterHTTPPagesPolicy
> 获取集群的自定义页面设置

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/findNodeClusterHTTPPagesPolicy`
- RPC：`rpc findNodeClusterHTTPPagesPolicy(FindNodeClusterHTTPPagesPolicyRequest) returns (FindNodeClusterHTTPPagesPolicyResponse);`

**请求对象 (`FindNodeClusterHTTPPagesPolicyRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID"
}
```

**响应对象 (`FindNodeClusterHTTPPagesPolicyResponse`)**

```json
{
  "httpPagesPolicyJSON": "bytes // HTTP自定义页面策略配置"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/findNodeClusterHTTPPagesPolicy" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findNodeClusterHealthCheckConfig
> 查找集群的健康检查配置

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/findNodeClusterHealthCheckConfig`
- RPC：`rpc findNodeClusterHealthCheckConfig (FindNodeClusterHealthCheckConfigRequest) returns (FindNodeClusterHealthCheckConfigResponse);`

**请求对象 (`FindNodeClusterHealthCheckConfigRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID"
}
```

**响应对象 (`FindNodeClusterHealthCheckConfigResponse`)**

```json
{
  "healthCheckJSON": "bytes"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/findNodeClusterHealthCheckConfig" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findNodeClusterNetworkSecurityPolicy
> 获取集群的网络安全策略

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/findNodeClusterNetworkSecurityPolicy`
- RPC：`rpc findNodeClusterNetworkSecurityPolicy(FindNodeClusterNetworkSecurityPolicyRequest) returns (FindNodeClusterNetworkSecurityPolicyResponse);`

**请求对象 (`FindNodeClusterNetworkSecurityPolicyRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID"
}
```

**响应对象 (`FindNodeClusterNetworkSecurityPolicyResponse`)**

```json
{
  "networkSecurityPolicyJSON": "bytes // 网络安全策略配置"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/findNodeClusterNetworkSecurityPolicy" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findNodeClusterSystemService
> 查找集群的系统服务设置

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/findNodeClusterSystemService`
- RPC：`rpc findNodeClusterSystemService (FindNodeClusterSystemServiceRequest) returns (FindNodeClusterSystemServiceResponse);`

**请求对象 (`FindNodeClusterSystemServiceRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID",
  "type": "string"
}
```

**响应对象 (`FindNodeClusterSystemServiceResponse`)**

```json
{
  "paramsJSON": "bytes"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/findNodeClusterSystemService" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## listEnabledNodeClusters
> 列出单页集群

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/listEnabledNodeClusters`
- RPC：`rpc listEnabledNodeClusters (ListEnabledNodeClustersRequest) returns (ListEnabledNodeClustersResponse);`

**请求对象 (`ListEnabledNodeClustersRequest`)**

```json
{
  "offset": "int64 // 读取位置",
  "size": "int64 // 数量，通常不能小于0",
  "keyword": "string // 可选项，搜索关键词",
  "idDesc": "bool // 可选项，是否按照ID倒序排列",
  "idAsc": "bool // 可选项，是否按照ID正序排列"
}
```

**响应对象 (`ListEnabledNodeClustersResponse`)**

```json
{
  "nodeClusters": "[]NodeCluster"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/listEnabledNodeClusters" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeCluster
> 修改集群

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/updateNodeCluster`
- RPC：`rpc updateNodeCluster (UpdateNodeClusterRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeClusterRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID",
  "name": "string // 名称",
  "nodeGrantId": "int64",
  "installDir": "string",
  "timeZone": "string",
  "nodeMaxThreads": "int32",
  "autoOpenPorts": "bool",
  "clockJSON": "bytes",
  "autoRemoteStart": "bool",
  "autoInstallNftables": "bool",
  "sshParamsJSON": "bytes",
  "autoSystemTuning": "bool // 是否自动调节系统参数",
  "autoTrimDisks": "bool // 是否自动TRIM硬盘",
  "maxConcurrentReads": "int32 // 最大并发读",
  "maxConcurrentWrites": "int32 // 最大并发写"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/updateNodeCluster" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeClusterDDoSProtection
> 修改集群的DDoS设置

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/updateNodeClusterDDoSProtection`
- RPC：`rpc updateNodeClusterDDoSProtection(UpdateNodeClusterDDoSProtectionRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeClusterDDoSProtectionRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID",
  "ddosProtectionJSON": "bytes"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/updateNodeClusterDDoSProtection" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeClusterDNS
> 修改集群的域名设置

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/updateNodeClusterDNS`
- RPC：`rpc updateNodeClusterDNS (UpdateNodeClusterDNSRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeClusterDNSRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID",
  "dnsName": "string",
  "dnsDomainId": "int64",
  "nodesAutoSync": "bool",
  "serversAutoSync": "bool",
  "cnameRecords": "[]string",
  "ttl": "int32",
  "cnameAsDomain": "bool",
  "includingLnNodes": "bool"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/updateNodeClusterDNS" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeClusterGlobalServerConfig
> 修改集群的全局服务设置

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/updateNodeClusterGlobalServerConfig`
- RPC：`rpc updateNodeClusterGlobalServerConfig(UpdateNodeClusterGlobalServerConfigRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeClusterGlobalServerConfigRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID",
  "globalServerConfigJSON": "bytes // 网站全局配置"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/updateNodeClusterGlobalServerConfig" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeClusterGlobalSetting
> 更新集群的单个全局设置

- 角色：`admin`, `user`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/updateNodeClusterGlobalSetting`
- RPC：`rpc updateNodeClusterGlobalSetting(UpdateNodeClusterGlobalSettingRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeClusterGlobalSettingRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID",
  "setting": "string // 全局设置",
  "value": "bool // 设置值"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/updateNodeClusterGlobalSetting" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeClusterGlobalSettings
> 更新集群的全局设置

- 角色：`admin`, `user`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/updateNodeClusterGlobalSettings`
- RPC：`rpc updateNodeClusterGlobalSettings(UpdateNodeClusterGlobalSettingsRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeClusterGlobalSettingsRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID",
  "settings": "map // 全局设置"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/updateNodeClusterGlobalSettings" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeClusterHTTP3Policy
> 修改集群的HTTP3设置

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/updateNodeClusterHTTP3Policy`
- RPC：`rpc updateNodeClusterHTTP3Policy(UpdateNodeClusterHTTP3PolicyRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeClusterHTTP3PolicyRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID",
  "http3PolicyJSON": "bytes // HTTP3策略配置"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/updateNodeClusterHTTP3Policy" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeClusterHTTPCCPolicy
> 设置集群的HTTP CC策略

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/updateNodeClusterHTTPCCPolicy`
- RPC：`rpc updateNodeClusterHTTPCCPolicy(UpdateNodeClusterHTTPCCPolicyRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeClusterHTTPCCPolicyRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID",
  "httpCCPolicyJSON": "bytes"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/updateNodeClusterHTTPCCPolicy" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeClusterHTTPCachePolicyId
> 修改集群的缓存策略

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/updateNodeClusterHTTPCachePolicyId`
- RPC：`rpc updateNodeClusterHTTPCachePolicyId (UpdateNodeClusterHTTPCachePolicyIdRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeClusterHTTPCachePolicyIdRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID",
  "httpCachePolicyId": "int64"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/updateNodeClusterHTTPCachePolicyId" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeClusterHTTPFirewallPolicyId
> 修改集群的WAF策略

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/updateNodeClusterHTTPFirewallPolicyId`
- RPC：`rpc updateNodeClusterHTTPFirewallPolicyId (UpdateNodeClusterHTTPFirewallPolicyIdRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeClusterHTTPFirewallPolicyIdRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID",
  "httpFirewallPolicyId": "int64"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/updateNodeClusterHTTPFirewallPolicyId" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeClusterHTTPPagesPolicy
> 修改集群的自定义页面设置

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/updateNodeClusterHTTPPagesPolicy`
- RPC：`rpc updateNodeClusterHTTPPagesPolicy(UpdateNodeClusterHTTPPagesPolicyRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeClusterHTTPPagesPolicyRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID",
  "httpPagesPolicyJSON": "bytes // HTTP自定义页面策略配置"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/updateNodeClusterHTTPPagesPolicy" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeClusterHealthCheck
> 修改集群健康检查设置

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/updateNodeClusterHealthCheck`
- RPC：`rpc updateNodeClusterHealthCheck (UpdateNodeClusterHealthCheckRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeClusterHealthCheckRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID",
  "healthCheckJSON": "bytes"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/updateNodeClusterHealthCheck" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeClusterNetworkSecurityPolicy
> 修改集群的网络安全策略

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/updateNodeClusterNetworkSecurityPolicy`
- RPC：`rpc updateNodeClusterNetworkSecurityPolicy(UpdateNodeClusterNetworkSecurityPolicyRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeClusterNetworkSecurityPolicyRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID",
  "networkSecurityPolicyJSON": "bytes // 网络安全策略配置"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/updateNodeClusterNetworkSecurityPolicy" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeClusterPinned
> 设置集群是否置顶

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/updateNodeClusterPinned`
- RPC：`rpc updateNodeClusterPinned(UpdateNodeClusterPinnedRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeClusterPinnedRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID",
  "isPinned": "bool"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/updateNodeClusterPinned" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeClusterSystemService
> 修改集群的系统服务设置

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/updateNodeClusterSystemService`
- RPC：`rpc updateNodeClusterSystemService (UpdateNodeClusterSystemServiceRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeClusterSystemServiceRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID",
  "type": "string",
  "paramsJSON": "bytes"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/updateNodeClusterSystemService" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeClusterTOA
> 修改集群的TOA设置

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/updateNodeClusterTOA`
- RPC：`rpc updateNodeClusterTOA (UpdateNodeClusterTOARequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeClusterTOARequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID",
  "toaJSON": "bytes"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/updateNodeClusterTOA" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeClusterUAMPolicy
> 设置集群的UAM策略

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/updateNodeClusterUAMPolicy`
- RPC：`rpc updateNodeClusterUAMPolicy(UpdateNodeClusterUAMPolicyRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeClusterUAMPolicyRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID",
  "uamPolicyJSON": "bytes"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/updateNodeClusterUAMPolicy" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeClusterWebPPolicy
> 设置集群WebP策略

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeClusterService/updateNodeClusterWebPPolicy`
- RPC：`rpc updateNodeClusterWebPPolicy(UpdateNodeClusterWebPPolicyRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeClusterWebPPolicyRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID",
  "webPPolicyJSON": "bytes"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeClusterService/updateNodeClusterWebPPolicy" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---
