@alicloud/cs20151215 3.0.19 → 3.0.21
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/client.d.ts +990 -148
- package/dist/client.js +1639 -253
- package/dist/client.js.map +1 -1
- package/package.json +4 -4
- package/src/client.ts +1949 -308
package/dist/client.js
CHANGED
|
@@ -165,6 +165,28 @@ class StandardComponentsValue extends $tea.Model {
|
|
|
165
165
|
}
|
|
166
166
|
}
|
|
167
167
|
exports.StandardComponentsValue = StandardComponentsValue;
|
|
168
|
+
class QuotasValue extends $tea.Model {
|
|
169
|
+
constructor(map) {
|
|
170
|
+
super(map);
|
|
171
|
+
}
|
|
172
|
+
static names() {
|
|
173
|
+
return {
|
|
174
|
+
quota: 'quota',
|
|
175
|
+
operationCode: 'operation_code',
|
|
176
|
+
adjustable: 'adjustable',
|
|
177
|
+
unit: 'unit',
|
|
178
|
+
};
|
|
179
|
+
}
|
|
180
|
+
static types() {
|
|
181
|
+
return {
|
|
182
|
+
quota: 'string',
|
|
183
|
+
operationCode: 'string',
|
|
184
|
+
adjustable: 'boolean',
|
|
185
|
+
unit: 'string',
|
|
186
|
+
};
|
|
187
|
+
}
|
|
188
|
+
}
|
|
189
|
+
exports.QuotasValue = QuotasValue;
|
|
168
190
|
class AttachInstancesRequest extends $tea.Model {
|
|
169
191
|
constructor(map) {
|
|
170
192
|
super(map);
|
|
@@ -243,6 +265,66 @@ class AttachInstancesResponse extends $tea.Model {
|
|
|
243
265
|
}
|
|
244
266
|
}
|
|
245
267
|
exports.AttachInstancesResponse = AttachInstancesResponse;
|
|
268
|
+
class AttachInstancesToNodePoolRequest extends $tea.Model {
|
|
269
|
+
constructor(map) {
|
|
270
|
+
super(map);
|
|
271
|
+
}
|
|
272
|
+
static names() {
|
|
273
|
+
return {
|
|
274
|
+
formatDisk: 'format_disk',
|
|
275
|
+
instances: 'instances',
|
|
276
|
+
keepInstanceName: 'keep_instance_name',
|
|
277
|
+
password: 'password',
|
|
278
|
+
};
|
|
279
|
+
}
|
|
280
|
+
static types() {
|
|
281
|
+
return {
|
|
282
|
+
formatDisk: 'boolean',
|
|
283
|
+
instances: { 'type': 'array', 'itemType': 'string' },
|
|
284
|
+
keepInstanceName: 'boolean',
|
|
285
|
+
password: 'string',
|
|
286
|
+
};
|
|
287
|
+
}
|
|
288
|
+
}
|
|
289
|
+
exports.AttachInstancesToNodePoolRequest = AttachInstancesToNodePoolRequest;
|
|
290
|
+
class AttachInstancesToNodePoolResponseBody extends $tea.Model {
|
|
291
|
+
constructor(map) {
|
|
292
|
+
super(map);
|
|
293
|
+
}
|
|
294
|
+
static names() {
|
|
295
|
+
return {
|
|
296
|
+
requestId: 'request_id',
|
|
297
|
+
taskId: 'task_id',
|
|
298
|
+
};
|
|
299
|
+
}
|
|
300
|
+
static types() {
|
|
301
|
+
return {
|
|
302
|
+
requestId: 'string',
|
|
303
|
+
taskId: 'string',
|
|
304
|
+
};
|
|
305
|
+
}
|
|
306
|
+
}
|
|
307
|
+
exports.AttachInstancesToNodePoolResponseBody = AttachInstancesToNodePoolResponseBody;
|
|
308
|
+
class AttachInstancesToNodePoolResponse extends $tea.Model {
|
|
309
|
+
constructor(map) {
|
|
310
|
+
super(map);
|
|
311
|
+
}
|
|
312
|
+
static names() {
|
|
313
|
+
return {
|
|
314
|
+
headers: 'headers',
|
|
315
|
+
statusCode: 'statusCode',
|
|
316
|
+
body: 'body',
|
|
317
|
+
};
|
|
318
|
+
}
|
|
319
|
+
static types() {
|
|
320
|
+
return {
|
|
321
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
322
|
+
statusCode: 'number',
|
|
323
|
+
body: AttachInstancesToNodePoolResponseBody,
|
|
324
|
+
};
|
|
325
|
+
}
|
|
326
|
+
}
|
|
327
|
+
exports.AttachInstancesToNodePoolResponse = AttachInstancesToNodePoolResponse;
|
|
246
328
|
class CancelClusterUpgradeResponse extends $tea.Model {
|
|
247
329
|
constructor(map) {
|
|
248
330
|
super(map);
|
|
@@ -331,6 +413,48 @@ class CancelWorkflowResponse extends $tea.Model {
|
|
|
331
413
|
}
|
|
332
414
|
}
|
|
333
415
|
exports.CancelWorkflowResponse = CancelWorkflowResponse;
|
|
416
|
+
class CheckControlPlaneLogEnableResponseBody extends $tea.Model {
|
|
417
|
+
constructor(map) {
|
|
418
|
+
super(map);
|
|
419
|
+
}
|
|
420
|
+
static names() {
|
|
421
|
+
return {
|
|
422
|
+
aliuid: 'aliuid',
|
|
423
|
+
components: 'components',
|
|
424
|
+
logProject: 'log_project',
|
|
425
|
+
logTtl: 'log_ttl',
|
|
426
|
+
};
|
|
427
|
+
}
|
|
428
|
+
static types() {
|
|
429
|
+
return {
|
|
430
|
+
aliuid: 'string',
|
|
431
|
+
components: { 'type': 'array', 'itemType': 'string' },
|
|
432
|
+
logProject: 'string',
|
|
433
|
+
logTtl: 'string',
|
|
434
|
+
};
|
|
435
|
+
}
|
|
436
|
+
}
|
|
437
|
+
exports.CheckControlPlaneLogEnableResponseBody = CheckControlPlaneLogEnableResponseBody;
|
|
438
|
+
class CheckControlPlaneLogEnableResponse extends $tea.Model {
|
|
439
|
+
constructor(map) {
|
|
440
|
+
super(map);
|
|
441
|
+
}
|
|
442
|
+
static names() {
|
|
443
|
+
return {
|
|
444
|
+
headers: 'headers',
|
|
445
|
+
statusCode: 'statusCode',
|
|
446
|
+
body: 'body',
|
|
447
|
+
};
|
|
448
|
+
}
|
|
449
|
+
static types() {
|
|
450
|
+
return {
|
|
451
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
452
|
+
statusCode: 'number',
|
|
453
|
+
body: CheckControlPlaneLogEnableResponseBody,
|
|
454
|
+
};
|
|
455
|
+
}
|
|
456
|
+
}
|
|
457
|
+
exports.CheckControlPlaneLogEnableResponse = CheckControlPlaneLogEnableResponse;
|
|
334
458
|
class CreateAutoscalingConfigRequest extends $tea.Model {
|
|
335
459
|
constructor(map) {
|
|
336
460
|
super(map);
|
|
@@ -338,10 +462,17 @@ class CreateAutoscalingConfigRequest extends $tea.Model {
|
|
|
338
462
|
static names() {
|
|
339
463
|
return {
|
|
340
464
|
coolDownDuration: 'cool_down_duration',
|
|
465
|
+
daemonsetEvictionForNodes: 'daemonset_eviction_for_nodes',
|
|
341
466
|
expander: 'expander',
|
|
342
467
|
gpuUtilizationThreshold: 'gpu_utilization_threshold',
|
|
468
|
+
maxGracefulTerminationSec: 'max_graceful_termination_sec',
|
|
469
|
+
minReplicaCount: 'min_replica_count',
|
|
470
|
+
recycleNodeDeletionEnabled: 'recycle_node_deletion_enabled',
|
|
343
471
|
scaleDownEnabled: 'scale_down_enabled',
|
|
472
|
+
scaleUpFromZero: 'scale_up_from_zero',
|
|
344
473
|
scanInterval: 'scan_interval',
|
|
474
|
+
skipNodesWithLocalStorage: 'skip_nodes_with_local_storage',
|
|
475
|
+
skipNodesWithSystemPods: 'skip_nodes_with_system_pods',
|
|
345
476
|
unneededDuration: 'unneeded_duration',
|
|
346
477
|
utilizationThreshold: 'utilization_threshold',
|
|
347
478
|
};
|
|
@@ -349,10 +480,17 @@ class CreateAutoscalingConfigRequest extends $tea.Model {
|
|
|
349
480
|
static types() {
|
|
350
481
|
return {
|
|
351
482
|
coolDownDuration: 'string',
|
|
483
|
+
daemonsetEvictionForNodes: 'boolean',
|
|
352
484
|
expander: 'string',
|
|
353
485
|
gpuUtilizationThreshold: 'string',
|
|
486
|
+
maxGracefulTerminationSec: 'number',
|
|
487
|
+
minReplicaCount: 'number',
|
|
488
|
+
recycleNodeDeletionEnabled: 'boolean',
|
|
354
489
|
scaleDownEnabled: 'boolean',
|
|
490
|
+
scaleUpFromZero: 'boolean',
|
|
355
491
|
scanInterval: 'string',
|
|
492
|
+
skipNodesWithLocalStorage: 'boolean',
|
|
493
|
+
skipNodesWithSystemPods: 'boolean',
|
|
356
494
|
unneededDuration: 'string',
|
|
357
495
|
utilizationThreshold: 'string',
|
|
358
496
|
};
|
|
@@ -1003,6 +1141,22 @@ class DeleteClusterShrinkRequest extends $tea.Model {
|
|
|
1003
1141
|
}
|
|
1004
1142
|
}
|
|
1005
1143
|
exports.DeleteClusterShrinkRequest = DeleteClusterShrinkRequest;
|
|
1144
|
+
class DeleteClusterResponseBody extends $tea.Model {
|
|
1145
|
+
constructor(map) {
|
|
1146
|
+
super(map);
|
|
1147
|
+
}
|
|
1148
|
+
static names() {
|
|
1149
|
+
return {
|
|
1150
|
+
taskId: 'task_id',
|
|
1151
|
+
};
|
|
1152
|
+
}
|
|
1153
|
+
static types() {
|
|
1154
|
+
return {
|
|
1155
|
+
taskId: 'string',
|
|
1156
|
+
};
|
|
1157
|
+
}
|
|
1158
|
+
}
|
|
1159
|
+
exports.DeleteClusterResponseBody = DeleteClusterResponseBody;
|
|
1006
1160
|
class DeleteClusterResponse extends $tea.Model {
|
|
1007
1161
|
constructor(map) {
|
|
1008
1162
|
super(map);
|
|
@@ -1011,12 +1165,14 @@ class DeleteClusterResponse extends $tea.Model {
|
|
|
1011
1165
|
return {
|
|
1012
1166
|
headers: 'headers',
|
|
1013
1167
|
statusCode: 'statusCode',
|
|
1168
|
+
body: 'body',
|
|
1014
1169
|
};
|
|
1015
1170
|
}
|
|
1016
1171
|
static types() {
|
|
1017
1172
|
return {
|
|
1018
1173
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1019
1174
|
statusCode: 'number',
|
|
1175
|
+
body: DeleteClusterResponseBody,
|
|
1020
1176
|
};
|
|
1021
1177
|
}
|
|
1022
1178
|
}
|
|
@@ -1391,13 +1547,19 @@ class DescribeAddonsRequest extends $tea.Model {
|
|
|
1391
1547
|
}
|
|
1392
1548
|
static names() {
|
|
1393
1549
|
return {
|
|
1550
|
+
clusterProfile: 'cluster_profile',
|
|
1551
|
+
clusterSpec: 'cluster_spec',
|
|
1394
1552
|
clusterType: 'cluster_type',
|
|
1553
|
+
clusterVersion: 'cluster_version',
|
|
1395
1554
|
region: 'region',
|
|
1396
1555
|
};
|
|
1397
1556
|
}
|
|
1398
1557
|
static types() {
|
|
1399
1558
|
return {
|
|
1559
|
+
clusterProfile: 'string',
|
|
1560
|
+
clusterSpec: 'string',
|
|
1400
1561
|
clusterType: 'string',
|
|
1562
|
+
clusterVersion: 'string',
|
|
1401
1563
|
region: 'string',
|
|
1402
1564
|
};
|
|
1403
1565
|
}
|
|
@@ -1441,6 +1603,48 @@ class DescribeAddonsResponse extends $tea.Model {
|
|
|
1441
1603
|
}
|
|
1442
1604
|
}
|
|
1443
1605
|
exports.DescribeAddonsResponse = DescribeAddonsResponse;
|
|
1606
|
+
class DescribeClusterAddonInstanceResponseBody extends $tea.Model {
|
|
1607
|
+
constructor(map) {
|
|
1608
|
+
super(map);
|
|
1609
|
+
}
|
|
1610
|
+
static names() {
|
|
1611
|
+
return {
|
|
1612
|
+
config: 'config',
|
|
1613
|
+
name: 'name',
|
|
1614
|
+
state: 'state',
|
|
1615
|
+
version: 'version',
|
|
1616
|
+
};
|
|
1617
|
+
}
|
|
1618
|
+
static types() {
|
|
1619
|
+
return {
|
|
1620
|
+
config: 'string',
|
|
1621
|
+
name: 'string',
|
|
1622
|
+
state: 'string',
|
|
1623
|
+
version: 'string',
|
|
1624
|
+
};
|
|
1625
|
+
}
|
|
1626
|
+
}
|
|
1627
|
+
exports.DescribeClusterAddonInstanceResponseBody = DescribeClusterAddonInstanceResponseBody;
|
|
1628
|
+
class DescribeClusterAddonInstanceResponse extends $tea.Model {
|
|
1629
|
+
constructor(map) {
|
|
1630
|
+
super(map);
|
|
1631
|
+
}
|
|
1632
|
+
static names() {
|
|
1633
|
+
return {
|
|
1634
|
+
headers: 'headers',
|
|
1635
|
+
statusCode: 'statusCode',
|
|
1636
|
+
body: 'body',
|
|
1637
|
+
};
|
|
1638
|
+
}
|
|
1639
|
+
static types() {
|
|
1640
|
+
return {
|
|
1641
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1642
|
+
statusCode: 'number',
|
|
1643
|
+
body: DescribeClusterAddonInstanceResponseBody,
|
|
1644
|
+
};
|
|
1645
|
+
}
|
|
1646
|
+
}
|
|
1647
|
+
exports.DescribeClusterAddonInstanceResponse = DescribeClusterAddonInstanceResponse;
|
|
1444
1648
|
class DescribeClusterAddonMetadataResponseBody extends $tea.Model {
|
|
1445
1649
|
constructor(map) {
|
|
1446
1650
|
super(map);
|
|
@@ -1640,6 +1844,7 @@ class DescribeClusterDetailResponseBody extends $tea.Model {
|
|
|
1640
1844
|
name: 'name',
|
|
1641
1845
|
networkMode: 'network_mode',
|
|
1642
1846
|
nextVersion: 'next_version',
|
|
1847
|
+
parameters: 'parameters',
|
|
1643
1848
|
privateZone: 'private_zone',
|
|
1644
1849
|
profile: 'profile',
|
|
1645
1850
|
regionId: 'region_id',
|
|
@@ -1673,6 +1878,7 @@ class DescribeClusterDetailResponseBody extends $tea.Model {
|
|
|
1673
1878
|
name: 'string',
|
|
1674
1879
|
networkMode: 'string',
|
|
1675
1880
|
nextVersion: 'string',
|
|
1881
|
+
parameters: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1676
1882
|
privateZone: 'boolean',
|
|
1677
1883
|
profile: 'string',
|
|
1678
1884
|
regionId: 'string',
|
|
@@ -1726,7 +1932,7 @@ class DescribeClusterEventsRequest extends $tea.Model {
|
|
|
1726
1932
|
return {
|
|
1727
1933
|
pageNumber: 'number',
|
|
1728
1934
|
pageSize: 'number',
|
|
1729
|
-
taskId: '
|
|
1935
|
+
taskId: 'string',
|
|
1730
1936
|
};
|
|
1731
1937
|
}
|
|
1732
1938
|
}
|
|
@@ -2109,6 +2315,42 @@ class DescribeClusterV2UserKubeconfigResponse extends $tea.Model {
|
|
|
2109
2315
|
}
|
|
2110
2316
|
}
|
|
2111
2317
|
exports.DescribeClusterV2UserKubeconfigResponse = DescribeClusterV2UserKubeconfigResponse;
|
|
2318
|
+
class DescribeClusterVulsResponseBody extends $tea.Model {
|
|
2319
|
+
constructor(map) {
|
|
2320
|
+
super(map);
|
|
2321
|
+
}
|
|
2322
|
+
static names() {
|
|
2323
|
+
return {
|
|
2324
|
+
vulRecords: 'vul_records',
|
|
2325
|
+
};
|
|
2326
|
+
}
|
|
2327
|
+
static types() {
|
|
2328
|
+
return {
|
|
2329
|
+
vulRecords: { 'type': 'array', 'itemType': DescribeClusterVulsResponseBodyVulRecords },
|
|
2330
|
+
};
|
|
2331
|
+
}
|
|
2332
|
+
}
|
|
2333
|
+
exports.DescribeClusterVulsResponseBody = DescribeClusterVulsResponseBody;
|
|
2334
|
+
class DescribeClusterVulsResponse extends $tea.Model {
|
|
2335
|
+
constructor(map) {
|
|
2336
|
+
super(map);
|
|
2337
|
+
}
|
|
2338
|
+
static names() {
|
|
2339
|
+
return {
|
|
2340
|
+
headers: 'headers',
|
|
2341
|
+
statusCode: 'statusCode',
|
|
2342
|
+
body: 'body',
|
|
2343
|
+
};
|
|
2344
|
+
}
|
|
2345
|
+
static types() {
|
|
2346
|
+
return {
|
|
2347
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2348
|
+
statusCode: 'number',
|
|
2349
|
+
body: DescribeClusterVulsResponseBody,
|
|
2350
|
+
};
|
|
2351
|
+
}
|
|
2352
|
+
}
|
|
2353
|
+
exports.DescribeClusterVulsResponse = DescribeClusterVulsResponse;
|
|
2112
2354
|
class DescribeClustersRequest extends $tea.Model {
|
|
2113
2355
|
constructor(map) {
|
|
2114
2356
|
super(map);
|
|
@@ -2525,6 +2767,7 @@ class DescribeKubernetesVersionMetadataRequest extends $tea.Model {
|
|
|
2525
2767
|
return {
|
|
2526
2768
|
clusterType: 'ClusterType',
|
|
2527
2769
|
kubernetesVersion: 'KubernetesVersion',
|
|
2770
|
+
mode: 'Mode',
|
|
2528
2771
|
profile: 'Profile',
|
|
2529
2772
|
region: 'Region',
|
|
2530
2773
|
runtime: 'runtime',
|
|
@@ -2534,6 +2777,7 @@ class DescribeKubernetesVersionMetadataRequest extends $tea.Model {
|
|
|
2534
2777
|
return {
|
|
2535
2778
|
clusterType: 'string',
|
|
2536
2779
|
kubernetesVersion: 'string',
|
|
2780
|
+
mode: 'string',
|
|
2537
2781
|
profile: 'string',
|
|
2538
2782
|
region: 'string',
|
|
2539
2783
|
runtime: 'string',
|
|
@@ -2561,6 +2805,22 @@ class DescribeKubernetesVersionMetadataResponse extends $tea.Model {
|
|
|
2561
2805
|
}
|
|
2562
2806
|
}
|
|
2563
2807
|
exports.DescribeKubernetesVersionMetadataResponse = DescribeKubernetesVersionMetadataResponse;
|
|
2808
|
+
class DescribeNodePoolVulsRequest extends $tea.Model {
|
|
2809
|
+
constructor(map) {
|
|
2810
|
+
super(map);
|
|
2811
|
+
}
|
|
2812
|
+
static names() {
|
|
2813
|
+
return {
|
|
2814
|
+
necessity: 'necessity',
|
|
2815
|
+
};
|
|
2816
|
+
}
|
|
2817
|
+
static types() {
|
|
2818
|
+
return {
|
|
2819
|
+
necessity: 'string',
|
|
2820
|
+
};
|
|
2821
|
+
}
|
|
2822
|
+
}
|
|
2823
|
+
exports.DescribeNodePoolVulsRequest = DescribeNodePoolVulsRequest;
|
|
2564
2824
|
class DescribeNodePoolVulsResponseBody extends $tea.Model {
|
|
2565
2825
|
constructor(map) {
|
|
2566
2826
|
super(map);
|
|
@@ -2787,6 +3047,62 @@ class DescribePolicyInstancesStatusResponse extends $tea.Model {
|
|
|
2787
3047
|
}
|
|
2788
3048
|
}
|
|
2789
3049
|
exports.DescribePolicyInstancesStatusResponse = DescribePolicyInstancesStatusResponse;
|
|
3050
|
+
class DescribeSubaccountK8sClusterUserConfigRequest extends $tea.Model {
|
|
3051
|
+
constructor(map) {
|
|
3052
|
+
super(map);
|
|
3053
|
+
}
|
|
3054
|
+
static names() {
|
|
3055
|
+
return {
|
|
3056
|
+
privateIpAddress: 'PrivateIpAddress',
|
|
3057
|
+
temporaryDurationMinutes: 'TemporaryDurationMinutes',
|
|
3058
|
+
};
|
|
3059
|
+
}
|
|
3060
|
+
static types() {
|
|
3061
|
+
return {
|
|
3062
|
+
privateIpAddress: 'boolean',
|
|
3063
|
+
temporaryDurationMinutes: 'number',
|
|
3064
|
+
};
|
|
3065
|
+
}
|
|
3066
|
+
}
|
|
3067
|
+
exports.DescribeSubaccountK8sClusterUserConfigRequest = DescribeSubaccountK8sClusterUserConfigRequest;
|
|
3068
|
+
class DescribeSubaccountK8sClusterUserConfigResponseBody extends $tea.Model {
|
|
3069
|
+
constructor(map) {
|
|
3070
|
+
super(map);
|
|
3071
|
+
}
|
|
3072
|
+
static names() {
|
|
3073
|
+
return {
|
|
3074
|
+
config: 'config',
|
|
3075
|
+
expiration: 'expiration',
|
|
3076
|
+
};
|
|
3077
|
+
}
|
|
3078
|
+
static types() {
|
|
3079
|
+
return {
|
|
3080
|
+
config: 'string',
|
|
3081
|
+
expiration: 'string',
|
|
3082
|
+
};
|
|
3083
|
+
}
|
|
3084
|
+
}
|
|
3085
|
+
exports.DescribeSubaccountK8sClusterUserConfigResponseBody = DescribeSubaccountK8sClusterUserConfigResponseBody;
|
|
3086
|
+
class DescribeSubaccountK8sClusterUserConfigResponse extends $tea.Model {
|
|
3087
|
+
constructor(map) {
|
|
3088
|
+
super(map);
|
|
3089
|
+
}
|
|
3090
|
+
static names() {
|
|
3091
|
+
return {
|
|
3092
|
+
headers: 'headers',
|
|
3093
|
+
statusCode: 'statusCode',
|
|
3094
|
+
body: 'body',
|
|
3095
|
+
};
|
|
3096
|
+
}
|
|
3097
|
+
static types() {
|
|
3098
|
+
return {
|
|
3099
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3100
|
+
statusCode: 'number',
|
|
3101
|
+
body: DescribeSubaccountK8sClusterUserConfigResponseBody,
|
|
3102
|
+
};
|
|
3103
|
+
}
|
|
3104
|
+
}
|
|
3105
|
+
exports.DescribeSubaccountK8sClusterUserConfigResponse = DescribeSubaccountK8sClusterUserConfigResponse;
|
|
2790
3106
|
class DescribeTaskInfoResponseBody extends $tea.Model {
|
|
2791
3107
|
constructor(map) {
|
|
2792
3108
|
super(map);
|
|
@@ -2983,7 +3299,7 @@ class DescribeTriggerResponse extends $tea.Model {
|
|
|
2983
3299
|
}
|
|
2984
3300
|
}
|
|
2985
3301
|
exports.DescribeTriggerResponse = DescribeTriggerResponse;
|
|
2986
|
-
class
|
|
3302
|
+
class DescribeUserClusterNamespacesResponse extends $tea.Model {
|
|
2987
3303
|
constructor(map) {
|
|
2988
3304
|
super(map);
|
|
2989
3305
|
}
|
|
@@ -2998,22 +3314,44 @@ class DescribeUserPermissionResponse extends $tea.Model {
|
|
|
2998
3314
|
return {
|
|
2999
3315
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3000
3316
|
statusCode: 'number',
|
|
3001
|
-
body: { 'type': 'array', 'itemType':
|
|
3317
|
+
body: { 'type': 'array', 'itemType': 'string' },
|
|
3002
3318
|
};
|
|
3003
3319
|
}
|
|
3004
3320
|
}
|
|
3005
|
-
exports.
|
|
3006
|
-
class
|
|
3321
|
+
exports.DescribeUserClusterNamespacesResponse = DescribeUserClusterNamespacesResponse;
|
|
3322
|
+
class DescribeUserPermissionResponse extends $tea.Model {
|
|
3007
3323
|
constructor(map) {
|
|
3008
3324
|
super(map);
|
|
3009
3325
|
}
|
|
3010
3326
|
static names() {
|
|
3011
3327
|
return {
|
|
3012
|
-
|
|
3013
|
-
|
|
3014
|
-
|
|
3015
|
-
|
|
3016
|
-
|
|
3328
|
+
headers: 'headers',
|
|
3329
|
+
statusCode: 'statusCode',
|
|
3330
|
+
body: 'body',
|
|
3331
|
+
};
|
|
3332
|
+
}
|
|
3333
|
+
static types() {
|
|
3334
|
+
return {
|
|
3335
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3336
|
+
statusCode: 'number',
|
|
3337
|
+
body: { 'type': 'array', 'itemType': DescribeUserPermissionResponseBody },
|
|
3338
|
+
};
|
|
3339
|
+
}
|
|
3340
|
+
}
|
|
3341
|
+
exports.DescribeUserPermissionResponse = DescribeUserPermissionResponse;
|
|
3342
|
+
class DescribeUserQuotaResponseBody extends $tea.Model {
|
|
3343
|
+
constructor(map) {
|
|
3344
|
+
super(map);
|
|
3345
|
+
}
|
|
3346
|
+
static names() {
|
|
3347
|
+
return {
|
|
3348
|
+
amkClusterQuota: 'amk_cluster_quota',
|
|
3349
|
+
askClusterQuota: 'ask_cluster_quota',
|
|
3350
|
+
clusterNodepoolQuota: 'cluster_nodepool_quota',
|
|
3351
|
+
clusterQuota: 'cluster_quota',
|
|
3352
|
+
edgeImprovedNodepoolQuota: 'edge_improved_nodepool_quota',
|
|
3353
|
+
nodeQuota: 'node_quota',
|
|
3354
|
+
quotas: 'quotas',
|
|
3017
3355
|
};
|
|
3018
3356
|
}
|
|
3019
3357
|
static types() {
|
|
@@ -3022,7 +3360,9 @@ class DescribeUserQuotaResponseBody extends $tea.Model {
|
|
|
3022
3360
|
askClusterQuota: 'number',
|
|
3023
3361
|
clusterNodepoolQuota: 'number',
|
|
3024
3362
|
clusterQuota: 'number',
|
|
3363
|
+
edgeImprovedNodepoolQuota: DescribeUserQuotaResponseBodyEdgeImprovedNodepoolQuota,
|
|
3025
3364
|
nodeQuota: 'number',
|
|
3365
|
+
quotas: { 'type': 'map', 'keyType': 'string', 'valueType': QuotasValue },
|
|
3026
3366
|
};
|
|
3027
3367
|
}
|
|
3028
3368
|
}
|
|
@@ -3149,14 +3489,14 @@ class FixNodePoolVulsRequest extends $tea.Model {
|
|
|
3149
3489
|
return {
|
|
3150
3490
|
nodes: 'nodes',
|
|
3151
3491
|
rolloutPolicy: 'rollout_policy',
|
|
3152
|
-
|
|
3492
|
+
vuls: 'vuls',
|
|
3153
3493
|
};
|
|
3154
3494
|
}
|
|
3155
3495
|
static types() {
|
|
3156
3496
|
return {
|
|
3157
3497
|
nodes: { 'type': 'array', 'itemType': 'string' },
|
|
3158
3498
|
rolloutPolicy: FixNodePoolVulsRequestRolloutPolicy,
|
|
3159
|
-
|
|
3499
|
+
vuls: { 'type': 'array', 'itemType': 'string' },
|
|
3160
3500
|
};
|
|
3161
3501
|
}
|
|
3162
3502
|
}
|
|
@@ -4006,6 +4346,7 @@ class RemoveNodePoolNodesRequest extends $tea.Model {
|
|
|
4006
4346
|
static names() {
|
|
4007
4347
|
return {
|
|
4008
4348
|
drainNode: 'drain_node',
|
|
4349
|
+
instanceIds: 'instance_ids',
|
|
4009
4350
|
nodes: 'nodes',
|
|
4010
4351
|
releaseNode: 'release_node',
|
|
4011
4352
|
};
|
|
@@ -4013,6 +4354,7 @@ class RemoveNodePoolNodesRequest extends $tea.Model {
|
|
|
4013
4354
|
static types() {
|
|
4014
4355
|
return {
|
|
4015
4356
|
drainNode: 'boolean',
|
|
4357
|
+
instanceIds: { 'type': 'array', 'itemType': 'string' },
|
|
4016
4358
|
nodes: { 'type': 'array', 'itemType': 'string' },
|
|
4017
4359
|
releaseNode: 'boolean',
|
|
4018
4360
|
};
|
|
@@ -4026,6 +4368,7 @@ class RemoveNodePoolNodesShrinkRequest extends $tea.Model {
|
|
|
4026
4368
|
static names() {
|
|
4027
4369
|
return {
|
|
4028
4370
|
drainNode: 'drain_node',
|
|
4371
|
+
instanceIdsShrink: 'instance_ids',
|
|
4029
4372
|
nodesShrink: 'nodes',
|
|
4030
4373
|
releaseNode: 'release_node',
|
|
4031
4374
|
};
|
|
@@ -4033,6 +4376,7 @@ class RemoveNodePoolNodesShrinkRequest extends $tea.Model {
|
|
|
4033
4376
|
static types() {
|
|
4034
4377
|
return {
|
|
4035
4378
|
drainNode: 'boolean',
|
|
4379
|
+
instanceIdsShrink: 'string',
|
|
4036
4380
|
nodesShrink: 'string',
|
|
4037
4381
|
releaseNode: 'boolean',
|
|
4038
4382
|
};
|
|
@@ -4443,6 +4787,82 @@ class ScaleOutClusterResponse extends $tea.Model {
|
|
|
4443
4787
|
}
|
|
4444
4788
|
}
|
|
4445
4789
|
exports.ScaleOutClusterResponse = ScaleOutClusterResponse;
|
|
4790
|
+
class ScanClusterVulsResponseBody extends $tea.Model {
|
|
4791
|
+
constructor(map) {
|
|
4792
|
+
super(map);
|
|
4793
|
+
}
|
|
4794
|
+
static names() {
|
|
4795
|
+
return {
|
|
4796
|
+
requestId: 'request_id',
|
|
4797
|
+
taskId: 'task_id',
|
|
4798
|
+
};
|
|
4799
|
+
}
|
|
4800
|
+
static types() {
|
|
4801
|
+
return {
|
|
4802
|
+
requestId: 'string',
|
|
4803
|
+
taskId: 'string',
|
|
4804
|
+
};
|
|
4805
|
+
}
|
|
4806
|
+
}
|
|
4807
|
+
exports.ScanClusterVulsResponseBody = ScanClusterVulsResponseBody;
|
|
4808
|
+
class ScanClusterVulsResponse extends $tea.Model {
|
|
4809
|
+
constructor(map) {
|
|
4810
|
+
super(map);
|
|
4811
|
+
}
|
|
4812
|
+
static names() {
|
|
4813
|
+
return {
|
|
4814
|
+
headers: 'headers',
|
|
4815
|
+
statusCode: 'statusCode',
|
|
4816
|
+
body: 'body',
|
|
4817
|
+
};
|
|
4818
|
+
}
|
|
4819
|
+
static types() {
|
|
4820
|
+
return {
|
|
4821
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
4822
|
+
statusCode: 'number',
|
|
4823
|
+
body: ScanClusterVulsResponseBody,
|
|
4824
|
+
};
|
|
4825
|
+
}
|
|
4826
|
+
}
|
|
4827
|
+
exports.ScanClusterVulsResponse = ScanClusterVulsResponse;
|
|
4828
|
+
class StartAlertResponseBody extends $tea.Model {
|
|
4829
|
+
constructor(map) {
|
|
4830
|
+
super(map);
|
|
4831
|
+
}
|
|
4832
|
+
static names() {
|
|
4833
|
+
return {
|
|
4834
|
+
msg: 'msg',
|
|
4835
|
+
status: 'status',
|
|
4836
|
+
};
|
|
4837
|
+
}
|
|
4838
|
+
static types() {
|
|
4839
|
+
return {
|
|
4840
|
+
msg: 'string',
|
|
4841
|
+
status: 'boolean',
|
|
4842
|
+
};
|
|
4843
|
+
}
|
|
4844
|
+
}
|
|
4845
|
+
exports.StartAlertResponseBody = StartAlertResponseBody;
|
|
4846
|
+
class StartAlertResponse extends $tea.Model {
|
|
4847
|
+
constructor(map) {
|
|
4848
|
+
super(map);
|
|
4849
|
+
}
|
|
4850
|
+
static names() {
|
|
4851
|
+
return {
|
|
4852
|
+
headers: 'headers',
|
|
4853
|
+
statusCode: 'statusCode',
|
|
4854
|
+
body: 'body',
|
|
4855
|
+
};
|
|
4856
|
+
}
|
|
4857
|
+
static types() {
|
|
4858
|
+
return {
|
|
4859
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
4860
|
+
statusCode: 'number',
|
|
4861
|
+
body: StartAlertResponseBody,
|
|
4862
|
+
};
|
|
4863
|
+
}
|
|
4864
|
+
}
|
|
4865
|
+
exports.StartAlertResponse = StartAlertResponse;
|
|
4446
4866
|
class StartWorkflowRequest extends $tea.Model {
|
|
4447
4867
|
constructor(map) {
|
|
4448
4868
|
super(map);
|
|
@@ -4531,6 +4951,80 @@ class StartWorkflowResponse extends $tea.Model {
|
|
|
4531
4951
|
}
|
|
4532
4952
|
}
|
|
4533
4953
|
exports.StartWorkflowResponse = StartWorkflowResponse;
|
|
4954
|
+
class StopAlertResponseBody extends $tea.Model {
|
|
4955
|
+
constructor(map) {
|
|
4956
|
+
super(map);
|
|
4957
|
+
}
|
|
4958
|
+
static names() {
|
|
4959
|
+
return {
|
|
4960
|
+
msg: 'msg',
|
|
4961
|
+
status: 'status',
|
|
4962
|
+
};
|
|
4963
|
+
}
|
|
4964
|
+
static types() {
|
|
4965
|
+
return {
|
|
4966
|
+
msg: 'string',
|
|
4967
|
+
status: 'boolean',
|
|
4968
|
+
};
|
|
4969
|
+
}
|
|
4970
|
+
}
|
|
4971
|
+
exports.StopAlertResponseBody = StopAlertResponseBody;
|
|
4972
|
+
class StopAlertResponse extends $tea.Model {
|
|
4973
|
+
constructor(map) {
|
|
4974
|
+
super(map);
|
|
4975
|
+
}
|
|
4976
|
+
static names() {
|
|
4977
|
+
return {
|
|
4978
|
+
headers: 'headers',
|
|
4979
|
+
statusCode: 'statusCode',
|
|
4980
|
+
body: 'body',
|
|
4981
|
+
};
|
|
4982
|
+
}
|
|
4983
|
+
static types() {
|
|
4984
|
+
return {
|
|
4985
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
4986
|
+
statusCode: 'number',
|
|
4987
|
+
body: StopAlertResponseBody,
|
|
4988
|
+
};
|
|
4989
|
+
}
|
|
4990
|
+
}
|
|
4991
|
+
exports.StopAlertResponse = StopAlertResponse;
|
|
4992
|
+
class SyncClusterNodePoolResponseBody extends $tea.Model {
|
|
4993
|
+
constructor(map) {
|
|
4994
|
+
super(map);
|
|
4995
|
+
}
|
|
4996
|
+
static names() {
|
|
4997
|
+
return {
|
|
4998
|
+
requestId: 'RequestId',
|
|
4999
|
+
};
|
|
5000
|
+
}
|
|
5001
|
+
static types() {
|
|
5002
|
+
return {
|
|
5003
|
+
requestId: 'string',
|
|
5004
|
+
};
|
|
5005
|
+
}
|
|
5006
|
+
}
|
|
5007
|
+
exports.SyncClusterNodePoolResponseBody = SyncClusterNodePoolResponseBody;
|
|
5008
|
+
class SyncClusterNodePoolResponse extends $tea.Model {
|
|
5009
|
+
constructor(map) {
|
|
5010
|
+
super(map);
|
|
5011
|
+
}
|
|
5012
|
+
static names() {
|
|
5013
|
+
return {
|
|
5014
|
+
headers: 'headers',
|
|
5015
|
+
statusCode: 'statusCode',
|
|
5016
|
+
body: 'body',
|
|
5017
|
+
};
|
|
5018
|
+
}
|
|
5019
|
+
static types() {
|
|
5020
|
+
return {
|
|
5021
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
5022
|
+
statusCode: 'number',
|
|
5023
|
+
body: SyncClusterNodePoolResponseBody,
|
|
5024
|
+
};
|
|
5025
|
+
}
|
|
5026
|
+
}
|
|
5027
|
+
exports.SyncClusterNodePoolResponse = SyncClusterNodePoolResponse;
|
|
4534
5028
|
class TagResourcesRequest extends $tea.Model {
|
|
4535
5029
|
constructor(map) {
|
|
4536
5030
|
super(map);
|
|
@@ -4647,6 +5141,30 @@ class UntagResourcesRequest extends $tea.Model {
|
|
|
4647
5141
|
}
|
|
4648
5142
|
}
|
|
4649
5143
|
exports.UntagResourcesRequest = UntagResourcesRequest;
|
|
5144
|
+
class UntagResourcesShrinkRequest extends $tea.Model {
|
|
5145
|
+
constructor(map) {
|
|
5146
|
+
super(map);
|
|
5147
|
+
}
|
|
5148
|
+
static names() {
|
|
5149
|
+
return {
|
|
5150
|
+
all: 'all',
|
|
5151
|
+
regionId: 'region_id',
|
|
5152
|
+
resourceIdsShrink: 'resource_ids',
|
|
5153
|
+
resourceType: 'resource_type',
|
|
5154
|
+
tagKeysShrink: 'tag_keys',
|
|
5155
|
+
};
|
|
5156
|
+
}
|
|
5157
|
+
static types() {
|
|
5158
|
+
return {
|
|
5159
|
+
all: 'boolean',
|
|
5160
|
+
regionId: 'string',
|
|
5161
|
+
resourceIdsShrink: 'string',
|
|
5162
|
+
resourceType: 'string',
|
|
5163
|
+
tagKeysShrink: 'string',
|
|
5164
|
+
};
|
|
5165
|
+
}
|
|
5166
|
+
}
|
|
5167
|
+
exports.UntagResourcesShrinkRequest = UntagResourcesShrinkRequest;
|
|
4650
5168
|
class UntagResourcesResponseBody extends $tea.Model {
|
|
4651
5169
|
constructor(map) {
|
|
4652
5170
|
super(map);
|
|
@@ -4701,6 +5219,46 @@ class UpdateContactGroupForAlertResponse extends $tea.Model {
|
|
|
4701
5219
|
}
|
|
4702
5220
|
}
|
|
4703
5221
|
exports.UpdateContactGroupForAlertResponse = UpdateContactGroupForAlertResponse;
|
|
5222
|
+
class UpdateControlPlaneLogRequest extends $tea.Model {
|
|
5223
|
+
constructor(map) {
|
|
5224
|
+
super(map);
|
|
5225
|
+
}
|
|
5226
|
+
static names() {
|
|
5227
|
+
return {
|
|
5228
|
+
aliuid: 'aliuid',
|
|
5229
|
+
components: 'components',
|
|
5230
|
+
logProject: 'log_project',
|
|
5231
|
+
logTtl: 'log_ttl',
|
|
5232
|
+
};
|
|
5233
|
+
}
|
|
5234
|
+
static types() {
|
|
5235
|
+
return {
|
|
5236
|
+
aliuid: 'string',
|
|
5237
|
+
components: { 'type': 'array', 'itemType': 'string' },
|
|
5238
|
+
logProject: 'string',
|
|
5239
|
+
logTtl: 'string',
|
|
5240
|
+
};
|
|
5241
|
+
}
|
|
5242
|
+
}
|
|
5243
|
+
exports.UpdateControlPlaneLogRequest = UpdateControlPlaneLogRequest;
|
|
5244
|
+
class UpdateControlPlaneLogResponse extends $tea.Model {
|
|
5245
|
+
constructor(map) {
|
|
5246
|
+
super(map);
|
|
5247
|
+
}
|
|
5248
|
+
static names() {
|
|
5249
|
+
return {
|
|
5250
|
+
headers: 'headers',
|
|
5251
|
+
statusCode: 'statusCode',
|
|
5252
|
+
};
|
|
5253
|
+
}
|
|
5254
|
+
static types() {
|
|
5255
|
+
return {
|
|
5256
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
5257
|
+
statusCode: 'number',
|
|
5258
|
+
};
|
|
5259
|
+
}
|
|
5260
|
+
}
|
|
5261
|
+
exports.UpdateControlPlaneLogResponse = UpdateControlPlaneLogResponse;
|
|
4704
5262
|
class UpdateK8sClusterUserConfigExpireRequest extends $tea.Model {
|
|
4705
5263
|
constructor(map) {
|
|
4706
5264
|
super(map);
|
|
@@ -4786,6 +5344,7 @@ class UpgradeClusterRequest extends $tea.Model {
|
|
|
4786
5344
|
static names() {
|
|
4787
5345
|
return {
|
|
4788
5346
|
componentName: 'component_name',
|
|
5347
|
+
masterOnly: 'master_only',
|
|
4789
5348
|
nextVersion: 'next_version',
|
|
4790
5349
|
version: 'version',
|
|
4791
5350
|
};
|
|
@@ -4793,6 +5352,7 @@ class UpgradeClusterRequest extends $tea.Model {
|
|
|
4793
5352
|
static types() {
|
|
4794
5353
|
return {
|
|
4795
5354
|
componentName: 'string',
|
|
5355
|
+
masterOnly: 'boolean',
|
|
4796
5356
|
nextVersion: 'string',
|
|
4797
5357
|
version: 'string',
|
|
4798
5358
|
};
|
|
@@ -4851,6 +5411,66 @@ class UpgradeClusterAddonsResponse extends $tea.Model {
|
|
|
4851
5411
|
}
|
|
4852
5412
|
}
|
|
4853
5413
|
exports.UpgradeClusterAddonsResponse = UpgradeClusterAddonsResponse;
|
|
5414
|
+
class UpgradeClusterNodepoolRequest extends $tea.Model {
|
|
5415
|
+
constructor(map) {
|
|
5416
|
+
super(map);
|
|
5417
|
+
}
|
|
5418
|
+
static names() {
|
|
5419
|
+
return {
|
|
5420
|
+
imageId: 'image_id',
|
|
5421
|
+
kubernetesVersion: 'kubernetes_version',
|
|
5422
|
+
runtimeType: 'runtime_type',
|
|
5423
|
+
runtimeVersion: 'runtime_version',
|
|
5424
|
+
};
|
|
5425
|
+
}
|
|
5426
|
+
static types() {
|
|
5427
|
+
return {
|
|
5428
|
+
imageId: 'string',
|
|
5429
|
+
kubernetesVersion: 'string',
|
|
5430
|
+
runtimeType: 'string',
|
|
5431
|
+
runtimeVersion: 'string',
|
|
5432
|
+
};
|
|
5433
|
+
}
|
|
5434
|
+
}
|
|
5435
|
+
exports.UpgradeClusterNodepoolRequest = UpgradeClusterNodepoolRequest;
|
|
5436
|
+
class UpgradeClusterNodepoolResponseBody extends $tea.Model {
|
|
5437
|
+
constructor(map) {
|
|
5438
|
+
super(map);
|
|
5439
|
+
}
|
|
5440
|
+
static names() {
|
|
5441
|
+
return {
|
|
5442
|
+
requestId: 'RequestId',
|
|
5443
|
+
taskId: 'task_id',
|
|
5444
|
+
};
|
|
5445
|
+
}
|
|
5446
|
+
static types() {
|
|
5447
|
+
return {
|
|
5448
|
+
requestId: 'string',
|
|
5449
|
+
taskId: 'string',
|
|
5450
|
+
};
|
|
5451
|
+
}
|
|
5452
|
+
}
|
|
5453
|
+
exports.UpgradeClusterNodepoolResponseBody = UpgradeClusterNodepoolResponseBody;
|
|
5454
|
+
class UpgradeClusterNodepoolResponse extends $tea.Model {
|
|
5455
|
+
constructor(map) {
|
|
5456
|
+
super(map);
|
|
5457
|
+
}
|
|
5458
|
+
static names() {
|
|
5459
|
+
return {
|
|
5460
|
+
headers: 'headers',
|
|
5461
|
+
statusCode: 'statusCode',
|
|
5462
|
+
body: 'body',
|
|
5463
|
+
};
|
|
5464
|
+
}
|
|
5465
|
+
static types() {
|
|
5466
|
+
return {
|
|
5467
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
5468
|
+
statusCode: 'number',
|
|
5469
|
+
body: UpgradeClusterNodepoolResponseBody,
|
|
5470
|
+
};
|
|
5471
|
+
}
|
|
5472
|
+
}
|
|
5473
|
+
exports.UpgradeClusterNodepoolResponse = UpgradeClusterNodepoolResponse;
|
|
4854
5474
|
class AttachInstancesResponseBodyList extends $tea.Model {
|
|
4855
5475
|
constructor(map) {
|
|
4856
5476
|
super(map);
|
|
@@ -5037,20 +5657,38 @@ class CreateClusterNodePoolRequestNodepoolInfo extends $tea.Model {
|
|
|
5037
5657
|
}
|
|
5038
5658
|
}
|
|
5039
5659
|
exports.CreateClusterNodePoolRequestNodepoolInfo = CreateClusterNodePoolRequestNodepoolInfo;
|
|
5040
|
-
class
|
|
5660
|
+
class CreateClusterNodePoolRequestScalingGroupPrivatePoolOptions extends $tea.Model {
|
|
5041
5661
|
constructor(map) {
|
|
5042
5662
|
super(map);
|
|
5043
5663
|
}
|
|
5044
5664
|
static names() {
|
|
5045
5665
|
return {
|
|
5046
|
-
|
|
5047
|
-
|
|
5666
|
+
id: 'id',
|
|
5667
|
+
matchCriteria: 'match_criteria',
|
|
5048
5668
|
};
|
|
5049
5669
|
}
|
|
5050
5670
|
static types() {
|
|
5051
5671
|
return {
|
|
5052
|
-
|
|
5053
|
-
|
|
5672
|
+
id: 'string',
|
|
5673
|
+
matchCriteria: 'string',
|
|
5674
|
+
};
|
|
5675
|
+
}
|
|
5676
|
+
}
|
|
5677
|
+
exports.CreateClusterNodePoolRequestScalingGroupPrivatePoolOptions = CreateClusterNodePoolRequestScalingGroupPrivatePoolOptions;
|
|
5678
|
+
class CreateClusterNodePoolRequestScalingGroupSpotPriceLimit extends $tea.Model {
|
|
5679
|
+
constructor(map) {
|
|
5680
|
+
super(map);
|
|
5681
|
+
}
|
|
5682
|
+
static names() {
|
|
5683
|
+
return {
|
|
5684
|
+
instanceType: 'instance_type',
|
|
5685
|
+
priceLimit: 'price_limit',
|
|
5686
|
+
};
|
|
5687
|
+
}
|
|
5688
|
+
static types() {
|
|
5689
|
+
return {
|
|
5690
|
+
instanceType: 'string',
|
|
5691
|
+
priceLimit: 'string',
|
|
5054
5692
|
};
|
|
5055
5693
|
}
|
|
5056
5694
|
}
|
|
@@ -5099,6 +5737,7 @@ class CreateClusterNodePoolRequestScalingGroup extends $tea.Model {
|
|
|
5099
5737
|
period: 'period',
|
|
5100
5738
|
periodUnit: 'period_unit',
|
|
5101
5739
|
platform: 'platform',
|
|
5740
|
+
privatePoolOptions: 'private_pool_options',
|
|
5102
5741
|
rdsInstances: 'rds_instances',
|
|
5103
5742
|
scalingPolicy: 'scaling_policy',
|
|
5104
5743
|
securityGroupId: 'security_group_id',
|
|
@@ -5136,6 +5775,7 @@ class CreateClusterNodePoolRequestScalingGroup extends $tea.Model {
|
|
|
5136
5775
|
period: 'number',
|
|
5137
5776
|
periodUnit: 'string',
|
|
5138
5777
|
platform: 'string',
|
|
5778
|
+
privatePoolOptions: CreateClusterNodePoolRequestScalingGroupPrivatePoolOptions,
|
|
5139
5779
|
rdsInstances: { 'type': 'array', 'itemType': 'string' },
|
|
5140
5780
|
scalingPolicy: 'string',
|
|
5141
5781
|
securityGroupId: 'string',
|
|
@@ -5449,6 +6089,24 @@ class DescribeClusterNodePoolDetailResponseBodyNodepoolInfo extends $tea.Model {
|
|
|
5449
6089
|
}
|
|
5450
6090
|
}
|
|
5451
6091
|
exports.DescribeClusterNodePoolDetailResponseBodyNodepoolInfo = DescribeClusterNodePoolDetailResponseBodyNodepoolInfo;
|
|
6092
|
+
class DescribeClusterNodePoolDetailResponseBodyScalingGroupPrivatePoolOptions extends $tea.Model {
|
|
6093
|
+
constructor(map) {
|
|
6094
|
+
super(map);
|
|
6095
|
+
}
|
|
6096
|
+
static names() {
|
|
6097
|
+
return {
|
|
6098
|
+
id: 'id',
|
|
6099
|
+
matchCriteria: 'match_criteria',
|
|
6100
|
+
};
|
|
6101
|
+
}
|
|
6102
|
+
static types() {
|
|
6103
|
+
return {
|
|
6104
|
+
id: 'string',
|
|
6105
|
+
matchCriteria: 'string',
|
|
6106
|
+
};
|
|
6107
|
+
}
|
|
6108
|
+
}
|
|
6109
|
+
exports.DescribeClusterNodePoolDetailResponseBodyScalingGroupPrivatePoolOptions = DescribeClusterNodePoolDetailResponseBodyScalingGroupPrivatePoolOptions;
|
|
5452
6110
|
class DescribeClusterNodePoolDetailResponseBodyScalingGroupSpotPriceLimit extends $tea.Model {
|
|
5453
6111
|
constructor(map) {
|
|
5454
6112
|
super(map);
|
|
@@ -5492,6 +6150,7 @@ class DescribeClusterNodePoolDetailResponseBodyScalingGroup extends $tea.Model {
|
|
|
5492
6150
|
period: 'period',
|
|
5493
6151
|
periodUnit: 'period_unit',
|
|
5494
6152
|
platform: 'platform',
|
|
6153
|
+
privatePoolOptions: 'private_pool_options',
|
|
5495
6154
|
ramPolicy: 'ram_policy',
|
|
5496
6155
|
rdsInstances: 'rds_instances',
|
|
5497
6156
|
scalingGroupId: 'scaling_group_id',
|
|
@@ -5530,6 +6189,7 @@ class DescribeClusterNodePoolDetailResponseBodyScalingGroup extends $tea.Model {
|
|
|
5530
6189
|
period: 'number',
|
|
5531
6190
|
periodUnit: 'string',
|
|
5532
6191
|
platform: 'string',
|
|
6192
|
+
privatePoolOptions: DescribeClusterNodePoolDetailResponseBodyScalingGroupPrivatePoolOptions,
|
|
5533
6193
|
ramPolicy: 'string',
|
|
5534
6194
|
rdsInstances: { 'type': 'array', 'itemType': 'string' },
|
|
5535
6195
|
scalingGroupId: 'string',
|
|
@@ -5749,6 +6409,24 @@ class DescribeClusterNodePoolsResponseBodyNodepoolsNodepoolInfo extends $tea.Mod
|
|
|
5749
6409
|
}
|
|
5750
6410
|
}
|
|
5751
6411
|
exports.DescribeClusterNodePoolsResponseBodyNodepoolsNodepoolInfo = DescribeClusterNodePoolsResponseBodyNodepoolsNodepoolInfo;
|
|
6412
|
+
class DescribeClusterNodePoolsResponseBodyNodepoolsScalingGroupPrivatePoolOptions extends $tea.Model {
|
|
6413
|
+
constructor(map) {
|
|
6414
|
+
super(map);
|
|
6415
|
+
}
|
|
6416
|
+
static names() {
|
|
6417
|
+
return {
|
|
6418
|
+
id: 'id',
|
|
6419
|
+
matchCriteria: 'match_criteria',
|
|
6420
|
+
};
|
|
6421
|
+
}
|
|
6422
|
+
static types() {
|
|
6423
|
+
return {
|
|
6424
|
+
id: 'string',
|
|
6425
|
+
matchCriteria: 'string',
|
|
6426
|
+
};
|
|
6427
|
+
}
|
|
6428
|
+
}
|
|
6429
|
+
exports.DescribeClusterNodePoolsResponseBodyNodepoolsScalingGroupPrivatePoolOptions = DescribeClusterNodePoolsResponseBodyNodepoolsScalingGroupPrivatePoolOptions;
|
|
5752
6430
|
class DescribeClusterNodePoolsResponseBodyNodepoolsScalingGroupSpotPriceLimit extends $tea.Model {
|
|
5753
6431
|
constructor(map) {
|
|
5754
6432
|
super(map);
|
|
@@ -5792,6 +6470,7 @@ class DescribeClusterNodePoolsResponseBodyNodepoolsScalingGroup extends $tea.Mod
|
|
|
5792
6470
|
period: 'period',
|
|
5793
6471
|
periodUnit: 'period_unit',
|
|
5794
6472
|
platform: 'platform',
|
|
6473
|
+
privatePoolOptions: 'private_pool_options',
|
|
5795
6474
|
ramPolicy: 'ram_policy',
|
|
5796
6475
|
rdsInstances: 'rds_instances',
|
|
5797
6476
|
scalingGroupId: 'scaling_group_id',
|
|
@@ -5830,6 +6509,7 @@ class DescribeClusterNodePoolsResponseBodyNodepoolsScalingGroup extends $tea.Mod
|
|
|
5830
6509
|
period: 'number',
|
|
5831
6510
|
periodUnit: 'string',
|
|
5832
6511
|
platform: 'string',
|
|
6512
|
+
privatePoolOptions: DescribeClusterNodePoolsResponseBodyNodepoolsScalingGroupPrivatePoolOptions,
|
|
5833
6513
|
ramPolicy: 'string',
|
|
5834
6514
|
rdsInstances: { 'type': 'array', 'itemType': 'string' },
|
|
5835
6515
|
scalingGroupId: 'string',
|
|
@@ -6095,6 +6775,36 @@ class DescribeClusterTasksResponseBodyTasks extends $tea.Model {
|
|
|
6095
6775
|
}
|
|
6096
6776
|
}
|
|
6097
6777
|
exports.DescribeClusterTasksResponseBodyTasks = DescribeClusterTasksResponseBodyTasks;
|
|
6778
|
+
class DescribeClusterVulsResponseBodyVulRecords extends $tea.Model {
|
|
6779
|
+
constructor(map) {
|
|
6780
|
+
super(map);
|
|
6781
|
+
}
|
|
6782
|
+
static names() {
|
|
6783
|
+
return {
|
|
6784
|
+
cveList: 'cve_list',
|
|
6785
|
+
necessity: 'necessity',
|
|
6786
|
+
nodeCount: 'node_count',
|
|
6787
|
+
nodepoolId: 'nodepool_id',
|
|
6788
|
+
nodepoolName: 'nodepool_name',
|
|
6789
|
+
vulAliasName: 'vul_alias_name',
|
|
6790
|
+
vulName: 'vul_name',
|
|
6791
|
+
vulType: 'vul_type',
|
|
6792
|
+
};
|
|
6793
|
+
}
|
|
6794
|
+
static types() {
|
|
6795
|
+
return {
|
|
6796
|
+
cveList: { 'type': 'array', 'itemType': 'string' },
|
|
6797
|
+
necessity: 'string',
|
|
6798
|
+
nodeCount: 'number',
|
|
6799
|
+
nodepoolId: 'string',
|
|
6800
|
+
nodepoolName: 'string',
|
|
6801
|
+
vulAliasName: 'string',
|
|
6802
|
+
vulName: 'string',
|
|
6803
|
+
vulType: 'string',
|
|
6804
|
+
};
|
|
6805
|
+
}
|
|
6806
|
+
}
|
|
6807
|
+
exports.DescribeClusterVulsResponseBodyVulRecords = DescribeClusterVulsResponseBodyVulRecords;
|
|
6098
6808
|
class DescribeClustersResponseBodyTags extends $tea.Model {
|
|
6099
6809
|
constructor(map) {
|
|
6100
6810
|
super(map);
|
|
@@ -6442,6 +7152,7 @@ class DescribeKubernetesVersionMetadataResponseBodyImages extends $tea.Model {
|
|
|
6442
7152
|
imageType: 'image_type',
|
|
6443
7153
|
osType: 'os_type',
|
|
6444
7154
|
imageCategory: 'image_category',
|
|
7155
|
+
architecture: 'architecture',
|
|
6445
7156
|
};
|
|
6446
7157
|
}
|
|
6447
7158
|
static types() {
|
|
@@ -6453,6 +7164,7 @@ class DescribeKubernetesVersionMetadataResponseBodyImages extends $tea.Model {
|
|
|
6453
7164
|
imageType: 'string',
|
|
6454
7165
|
osType: 'string',
|
|
6455
7166
|
imageCategory: 'string',
|
|
7167
|
+
architecture: 'string',
|
|
6456
7168
|
};
|
|
6457
7169
|
}
|
|
6458
7170
|
}
|
|
@@ -6468,7 +7180,9 @@ class DescribeKubernetesVersionMetadataResponseBody extends $tea.Model {
|
|
|
6468
7180
|
metaData: 'meta_data',
|
|
6469
7181
|
runtimes: 'runtimes',
|
|
6470
7182
|
version: 'version',
|
|
6471
|
-
|
|
7183
|
+
releaseDate: 'release_date',
|
|
7184
|
+
expirationDate: 'expiration_date',
|
|
7185
|
+
creatable: 'creatable',
|
|
6472
7186
|
};
|
|
6473
7187
|
}
|
|
6474
7188
|
static types() {
|
|
@@ -6478,7 +7192,9 @@ class DescribeKubernetesVersionMetadataResponseBody extends $tea.Model {
|
|
|
6478
7192
|
metaData: { 'type': 'map', 'keyType': 'string', 'valueType': 'any' },
|
|
6479
7193
|
runtimes: { 'type': 'array', 'itemType': Runtime },
|
|
6480
7194
|
version: 'string',
|
|
6481
|
-
|
|
7195
|
+
releaseDate: 'string',
|
|
7196
|
+
expirationDate: 'string',
|
|
7197
|
+
creatable: 'boolean',
|
|
6482
7198
|
};
|
|
6483
7199
|
}
|
|
6484
7200
|
}
|
|
@@ -6512,12 +7228,14 @@ class DescribeNodePoolVulsResponseBodyVulRecords extends $tea.Model {
|
|
|
6512
7228
|
static names() {
|
|
6513
7229
|
return {
|
|
6514
7230
|
instanceId: 'instance_id',
|
|
7231
|
+
nodeName: 'node_name',
|
|
6515
7232
|
vulList: 'vul_list',
|
|
6516
7233
|
};
|
|
6517
7234
|
}
|
|
6518
7235
|
static types() {
|
|
6519
7236
|
return {
|
|
6520
7237
|
instanceId: 'string',
|
|
7238
|
+
nodeName: 'string',
|
|
6521
7239
|
vulList: { 'type': 'array', 'itemType': DescribeNodePoolVulsResponseBodyVulRecordsVulList },
|
|
6522
7240
|
};
|
|
6523
7241
|
}
|
|
@@ -7009,6 +7727,26 @@ class DescribeUserPermissionResponseBody extends $tea.Model {
|
|
|
7009
7727
|
}
|
|
7010
7728
|
}
|
|
7011
7729
|
exports.DescribeUserPermissionResponseBody = DescribeUserPermissionResponseBody;
|
|
7730
|
+
class DescribeUserQuotaResponseBodyEdgeImprovedNodepoolQuota extends $tea.Model {
|
|
7731
|
+
constructor(map) {
|
|
7732
|
+
super(map);
|
|
7733
|
+
}
|
|
7734
|
+
static names() {
|
|
7735
|
+
return {
|
|
7736
|
+
bandwidth: 'bandwidth',
|
|
7737
|
+
count: 'count',
|
|
7738
|
+
period: 'period',
|
|
7739
|
+
};
|
|
7740
|
+
}
|
|
7741
|
+
static types() {
|
|
7742
|
+
return {
|
|
7743
|
+
bandwidth: 'number',
|
|
7744
|
+
count: 'number',
|
|
7745
|
+
period: 'number',
|
|
7746
|
+
};
|
|
7747
|
+
}
|
|
7748
|
+
}
|
|
7749
|
+
exports.DescribeUserQuotaResponseBodyEdgeImprovedNodepoolQuota = DescribeUserQuotaResponseBodyEdgeImprovedNodepoolQuota;
|
|
7012
7750
|
class DescribeWorkflowsResponseBodyJobs extends $tea.Model {
|
|
7013
7751
|
constructor(map) {
|
|
7014
7752
|
super(map);
|
|
@@ -7327,6 +8065,24 @@ class ModifyClusterNodePoolRequestNodepoolInfo extends $tea.Model {
|
|
|
7327
8065
|
}
|
|
7328
8066
|
}
|
|
7329
8067
|
exports.ModifyClusterNodePoolRequestNodepoolInfo = ModifyClusterNodePoolRequestNodepoolInfo;
|
|
8068
|
+
class ModifyClusterNodePoolRequestScalingGroupPrivatePoolOptions extends $tea.Model {
|
|
8069
|
+
constructor(map) {
|
|
8070
|
+
super(map);
|
|
8071
|
+
}
|
|
8072
|
+
static names() {
|
|
8073
|
+
return {
|
|
8074
|
+
id: 'id',
|
|
8075
|
+
matchCriteria: 'match_criteria',
|
|
8076
|
+
};
|
|
8077
|
+
}
|
|
8078
|
+
static types() {
|
|
8079
|
+
return {
|
|
8080
|
+
id: 'string',
|
|
8081
|
+
matchCriteria: 'string',
|
|
8082
|
+
};
|
|
8083
|
+
}
|
|
8084
|
+
}
|
|
8085
|
+
exports.ModifyClusterNodePoolRequestScalingGroupPrivatePoolOptions = ModifyClusterNodePoolRequestScalingGroupPrivatePoolOptions;
|
|
7330
8086
|
class ModifyClusterNodePoolRequestScalingGroupSpotPriceLimit extends $tea.Model {
|
|
7331
8087
|
constructor(map) {
|
|
7332
8088
|
super(map);
|
|
@@ -7369,6 +8125,7 @@ class ModifyClusterNodePoolRequestScalingGroup extends $tea.Model {
|
|
|
7369
8125
|
period: 'period',
|
|
7370
8126
|
periodUnit: 'period_unit',
|
|
7371
8127
|
platform: 'platform',
|
|
8128
|
+
privatePoolOptions: 'private_pool_options',
|
|
7372
8129
|
rdsInstances: 'rds_instances',
|
|
7373
8130
|
scalingPolicy: 'scaling_policy',
|
|
7374
8131
|
spotInstancePools: 'spot_instance_pools',
|
|
@@ -7402,6 +8159,7 @@ class ModifyClusterNodePoolRequestScalingGroup extends $tea.Model {
|
|
|
7402
8159
|
period: 'number',
|
|
7403
8160
|
periodUnit: 'string',
|
|
7404
8161
|
platform: 'string',
|
|
8162
|
+
privatePoolOptions: ModifyClusterNodePoolRequestScalingGroupPrivatePoolOptions,
|
|
7405
8163
|
rdsInstances: { 'type': 'array', 'itemType': 'string' },
|
|
7406
8164
|
scalingPolicy: 'string',
|
|
7407
8165
|
spotInstancePools: 'number',
|
|
@@ -7592,6 +8350,7 @@ class UpgradeClusterAddonsRequestBody extends $tea.Model {
|
|
|
7592
8350
|
componentName: 'component_name',
|
|
7593
8351
|
config: 'config',
|
|
7594
8352
|
nextVersion: 'next_version',
|
|
8353
|
+
policy: 'policy',
|
|
7595
8354
|
version: 'version',
|
|
7596
8355
|
};
|
|
7597
8356
|
}
|
|
@@ -7600,6 +8359,7 @@ class UpgradeClusterAddonsRequestBody extends $tea.Model {
|
|
|
7600
8359
|
componentName: 'string',
|
|
7601
8360
|
config: 'string',
|
|
7602
8361
|
nextVersion: 'string',
|
|
8362
|
+
policy: 'string',
|
|
7603
8363
|
version: 'string',
|
|
7604
8364
|
};
|
|
7605
8365
|
}
|
|
@@ -7654,11 +8414,6 @@ class Client extends openapi_client_1.default {
|
|
|
7654
8414
|
}
|
|
7655
8415
|
return endpoint_util_1.default.getEndpointRules(productId, regionId, endpointRule, network, suffix);
|
|
7656
8416
|
}
|
|
7657
|
-
async attachInstances(ClusterId, request) {
|
|
7658
|
-
let runtime = new $Util.RuntimeOptions({});
|
|
7659
|
-
let headers = {};
|
|
7660
|
-
return await this.attachInstancesWithOptions(ClusterId, request, headers, runtime);
|
|
7661
|
-
}
|
|
7662
8417
|
async attachInstancesWithOptions(ClusterId, request, headers, runtime) {
|
|
7663
8418
|
tea_util_1.default.validateModel(request);
|
|
7664
8419
|
let body = {};
|
|
@@ -7692,7 +8447,7 @@ class Client extends openapi_client_1.default {
|
|
|
7692
8447
|
if (!tea_util_1.default.isUnset(request.rdsInstances)) {
|
|
7693
8448
|
body["rds_instances"] = request.rdsInstances;
|
|
7694
8449
|
}
|
|
7695
|
-
if (!tea_util_1.default.isUnset(
|
|
8450
|
+
if (!tea_util_1.default.isUnset(request.runtime)) {
|
|
7696
8451
|
body["runtime"] = request.runtime;
|
|
7697
8452
|
}
|
|
7698
8453
|
if (!tea_util_1.default.isUnset(request.tags)) {
|
|
@@ -7718,10 +8473,47 @@ class Client extends openapi_client_1.default {
|
|
|
7718
8473
|
});
|
|
7719
8474
|
return $tea.cast(await this.callApi(params, req, runtime), new AttachInstancesResponse({}));
|
|
7720
8475
|
}
|
|
7721
|
-
async
|
|
8476
|
+
async attachInstances(ClusterId, request) {
|
|
7722
8477
|
let runtime = new $Util.RuntimeOptions({});
|
|
7723
8478
|
let headers = {};
|
|
7724
|
-
return await this.
|
|
8479
|
+
return await this.attachInstancesWithOptions(ClusterId, request, headers, runtime);
|
|
8480
|
+
}
|
|
8481
|
+
async attachInstancesToNodePoolWithOptions(ClusterId, NodepoolId, request, headers, runtime) {
|
|
8482
|
+
tea_util_1.default.validateModel(request);
|
|
8483
|
+
let body = {};
|
|
8484
|
+
if (!tea_util_1.default.isUnset(request.formatDisk)) {
|
|
8485
|
+
body["format_disk"] = request.formatDisk;
|
|
8486
|
+
}
|
|
8487
|
+
if (!tea_util_1.default.isUnset(request.instances)) {
|
|
8488
|
+
body["instances"] = request.instances;
|
|
8489
|
+
}
|
|
8490
|
+
if (!tea_util_1.default.isUnset(request.keepInstanceName)) {
|
|
8491
|
+
body["keep_instance_name"] = request.keepInstanceName;
|
|
8492
|
+
}
|
|
8493
|
+
if (!tea_util_1.default.isUnset(request.password)) {
|
|
8494
|
+
body["password"] = request.password;
|
|
8495
|
+
}
|
|
8496
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
8497
|
+
headers: headers,
|
|
8498
|
+
body: openapi_util_1.default.parseToMap(body),
|
|
8499
|
+
});
|
|
8500
|
+
let params = new $OpenApi.Params({
|
|
8501
|
+
action: "AttachInstancesToNodePool",
|
|
8502
|
+
version: "2015-12-15",
|
|
8503
|
+
protocol: "HTTPS",
|
|
8504
|
+
pathname: `/clusters/${openapi_util_1.default.getEncodeParam(ClusterId)}/nodepools/${openapi_util_1.default.getEncodeParam(NodepoolId)}/attach`,
|
|
8505
|
+
method: "POST",
|
|
8506
|
+
authType: "AK",
|
|
8507
|
+
style: "ROA",
|
|
8508
|
+
reqBodyType: "json",
|
|
8509
|
+
bodyType: "json",
|
|
8510
|
+
});
|
|
8511
|
+
return $tea.cast(await this.callApi(params, req, runtime), new AttachInstancesToNodePoolResponse({}));
|
|
8512
|
+
}
|
|
8513
|
+
async attachInstancesToNodePool(ClusterId, NodepoolId, request) {
|
|
8514
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
8515
|
+
let headers = {};
|
|
8516
|
+
return await this.attachInstancesToNodePoolWithOptions(ClusterId, NodepoolId, request, headers, runtime);
|
|
7725
8517
|
}
|
|
7726
8518
|
async cancelClusterUpgradeWithOptions(ClusterId, headers, runtime) {
|
|
7727
8519
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -7740,10 +8532,10 @@ class Client extends openapi_client_1.default {
|
|
|
7740
8532
|
});
|
|
7741
8533
|
return $tea.cast(await this.callApi(params, req, runtime), new CancelClusterUpgradeResponse({}));
|
|
7742
8534
|
}
|
|
7743
|
-
async
|
|
8535
|
+
async cancelClusterUpgrade(ClusterId) {
|
|
7744
8536
|
let runtime = new $Util.RuntimeOptions({});
|
|
7745
8537
|
let headers = {};
|
|
7746
|
-
return await this.
|
|
8538
|
+
return await this.cancelClusterUpgradeWithOptions(ClusterId, headers, runtime);
|
|
7747
8539
|
}
|
|
7748
8540
|
async cancelComponentUpgradeWithOptions(clusterId, componentId, headers, runtime) {
|
|
7749
8541
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -7762,10 +8554,10 @@ class Client extends openapi_client_1.default {
|
|
|
7762
8554
|
});
|
|
7763
8555
|
return $tea.cast(await this.callApi(params, req, runtime), new CancelComponentUpgradeResponse({}));
|
|
7764
8556
|
}
|
|
7765
|
-
async
|
|
8557
|
+
async cancelComponentUpgrade(clusterId, componentId) {
|
|
7766
8558
|
let runtime = new $Util.RuntimeOptions({});
|
|
7767
8559
|
let headers = {};
|
|
7768
|
-
return await this.
|
|
8560
|
+
return await this.cancelComponentUpgradeWithOptions(clusterId, componentId, headers, runtime);
|
|
7769
8561
|
}
|
|
7770
8562
|
async cancelTaskWithOptions(taskId, headers, runtime) {
|
|
7771
8563
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -7784,10 +8576,10 @@ class Client extends openapi_client_1.default {
|
|
|
7784
8576
|
});
|
|
7785
8577
|
return $tea.cast(await this.callApi(params, req, runtime), new CancelTaskResponse({}));
|
|
7786
8578
|
}
|
|
7787
|
-
async
|
|
8579
|
+
async cancelTask(taskId) {
|
|
7788
8580
|
let runtime = new $Util.RuntimeOptions({});
|
|
7789
8581
|
let headers = {};
|
|
7790
|
-
return await this.
|
|
8582
|
+
return await this.cancelTaskWithOptions(taskId, headers, runtime);
|
|
7791
8583
|
}
|
|
7792
8584
|
async cancelWorkflowWithOptions(workflowName, request, headers, runtime) {
|
|
7793
8585
|
tea_util_1.default.validateModel(request);
|
|
@@ -7812,10 +8604,32 @@ class Client extends openapi_client_1.default {
|
|
|
7812
8604
|
});
|
|
7813
8605
|
return $tea.cast(await this.callApi(params, req, runtime), new CancelWorkflowResponse({}));
|
|
7814
8606
|
}
|
|
7815
|
-
async
|
|
8607
|
+
async cancelWorkflow(workflowName, request) {
|
|
7816
8608
|
let runtime = new $Util.RuntimeOptions({});
|
|
7817
8609
|
let headers = {};
|
|
7818
|
-
return await this.
|
|
8610
|
+
return await this.cancelWorkflowWithOptions(workflowName, request, headers, runtime);
|
|
8611
|
+
}
|
|
8612
|
+
async checkControlPlaneLogEnableWithOptions(ClusterId, headers, runtime) {
|
|
8613
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
8614
|
+
headers: headers,
|
|
8615
|
+
});
|
|
8616
|
+
let params = new $OpenApi.Params({
|
|
8617
|
+
action: "CheckControlPlaneLogEnable",
|
|
8618
|
+
version: "2015-12-15",
|
|
8619
|
+
protocol: "HTTPS",
|
|
8620
|
+
pathname: `/clusters/${openapi_util_1.default.getEncodeParam(ClusterId)}/controlplanelog`,
|
|
8621
|
+
method: "GET",
|
|
8622
|
+
authType: "AK",
|
|
8623
|
+
style: "ROA",
|
|
8624
|
+
reqBodyType: "json",
|
|
8625
|
+
bodyType: "json",
|
|
8626
|
+
});
|
|
8627
|
+
return $tea.cast(await this.callApi(params, req, runtime), new CheckControlPlaneLogEnableResponse({}));
|
|
8628
|
+
}
|
|
8629
|
+
async checkControlPlaneLogEnable(ClusterId) {
|
|
8630
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
8631
|
+
let headers = {};
|
|
8632
|
+
return await this.checkControlPlaneLogEnableWithOptions(ClusterId, headers, runtime);
|
|
7819
8633
|
}
|
|
7820
8634
|
async createAutoscalingConfigWithOptions(ClusterId, request, headers, runtime) {
|
|
7821
8635
|
tea_util_1.default.validateModel(request);
|
|
@@ -7823,18 +8637,39 @@ class Client extends openapi_client_1.default {
|
|
|
7823
8637
|
if (!tea_util_1.default.isUnset(request.coolDownDuration)) {
|
|
7824
8638
|
body["cool_down_duration"] = request.coolDownDuration;
|
|
7825
8639
|
}
|
|
8640
|
+
if (!tea_util_1.default.isUnset(request.daemonsetEvictionForNodes)) {
|
|
8641
|
+
body["daemonset_eviction_for_nodes"] = request.daemonsetEvictionForNodes;
|
|
8642
|
+
}
|
|
7826
8643
|
if (!tea_util_1.default.isUnset(request.expander)) {
|
|
7827
8644
|
body["expander"] = request.expander;
|
|
7828
8645
|
}
|
|
7829
8646
|
if (!tea_util_1.default.isUnset(request.gpuUtilizationThreshold)) {
|
|
7830
8647
|
body["gpu_utilization_threshold"] = request.gpuUtilizationThreshold;
|
|
7831
8648
|
}
|
|
8649
|
+
if (!tea_util_1.default.isUnset(request.maxGracefulTerminationSec)) {
|
|
8650
|
+
body["max_graceful_termination_sec"] = request.maxGracefulTerminationSec;
|
|
8651
|
+
}
|
|
8652
|
+
if (!tea_util_1.default.isUnset(request.minReplicaCount)) {
|
|
8653
|
+
body["min_replica_count"] = request.minReplicaCount;
|
|
8654
|
+
}
|
|
8655
|
+
if (!tea_util_1.default.isUnset(request.recycleNodeDeletionEnabled)) {
|
|
8656
|
+
body["recycle_node_deletion_enabled"] = request.recycleNodeDeletionEnabled;
|
|
8657
|
+
}
|
|
7832
8658
|
if (!tea_util_1.default.isUnset(request.scaleDownEnabled)) {
|
|
7833
8659
|
body["scale_down_enabled"] = request.scaleDownEnabled;
|
|
7834
8660
|
}
|
|
8661
|
+
if (!tea_util_1.default.isUnset(request.scaleUpFromZero)) {
|
|
8662
|
+
body["scale_up_from_zero"] = request.scaleUpFromZero;
|
|
8663
|
+
}
|
|
7835
8664
|
if (!tea_util_1.default.isUnset(request.scanInterval)) {
|
|
7836
8665
|
body["scan_interval"] = request.scanInterval;
|
|
7837
8666
|
}
|
|
8667
|
+
if (!tea_util_1.default.isUnset(request.skipNodesWithLocalStorage)) {
|
|
8668
|
+
body["skip_nodes_with_local_storage"] = request.skipNodesWithLocalStorage;
|
|
8669
|
+
}
|
|
8670
|
+
if (!tea_util_1.default.isUnset(request.skipNodesWithSystemPods)) {
|
|
8671
|
+
body["skip_nodes_with_system_pods"] = request.skipNodesWithSystemPods;
|
|
8672
|
+
}
|
|
7838
8673
|
if (!tea_util_1.default.isUnset(request.unneededDuration)) {
|
|
7839
8674
|
body["unneeded_duration"] = request.unneededDuration;
|
|
7840
8675
|
}
|
|
@@ -7858,10 +8693,10 @@ class Client extends openapi_client_1.default {
|
|
|
7858
8693
|
});
|
|
7859
8694
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateAutoscalingConfigResponse({}));
|
|
7860
8695
|
}
|
|
7861
|
-
async
|
|
8696
|
+
async createAutoscalingConfig(ClusterId, request) {
|
|
7862
8697
|
let runtime = new $Util.RuntimeOptions({});
|
|
7863
8698
|
let headers = {};
|
|
7864
|
-
return await this.
|
|
8699
|
+
return await this.createAutoscalingConfigWithOptions(ClusterId, request, headers, runtime);
|
|
7865
8700
|
}
|
|
7866
8701
|
async createClusterWithOptions(request, headers, runtime) {
|
|
7867
8702
|
tea_util_1.default.validateModel(request);
|
|
@@ -8043,7 +8878,7 @@ class Client extends openapi_client_1.default {
|
|
|
8043
8878
|
if (!tea_util_1.default.isUnset(request.resourceGroupId)) {
|
|
8044
8879
|
body["resource_group_id"] = request.resourceGroupId;
|
|
8045
8880
|
}
|
|
8046
|
-
if (!tea_util_1.default.isUnset(
|
|
8881
|
+
if (!tea_util_1.default.isUnset(request.runtime)) {
|
|
8047
8882
|
body["runtime"] = request.runtime;
|
|
8048
8883
|
}
|
|
8049
8884
|
if (!tea_util_1.default.isUnset(request.securityGroupId)) {
|
|
@@ -8147,42 +8982,42 @@ class Client extends openapi_client_1.default {
|
|
|
8147
8982
|
});
|
|
8148
8983
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateClusterResponse({}));
|
|
8149
8984
|
}
|
|
8150
|
-
async
|
|
8985
|
+
async createCluster(request) {
|
|
8151
8986
|
let runtime = new $Util.RuntimeOptions({});
|
|
8152
8987
|
let headers = {};
|
|
8153
|
-
return await this.
|
|
8988
|
+
return await this.createClusterWithOptions(request, headers, runtime);
|
|
8154
8989
|
}
|
|
8155
8990
|
async createClusterNodePoolWithOptions(ClusterId, request, headers, runtime) {
|
|
8156
8991
|
tea_util_1.default.validateModel(request);
|
|
8157
8992
|
let body = {};
|
|
8158
|
-
if (!tea_util_1.default.isUnset(
|
|
8993
|
+
if (!tea_util_1.default.isUnset(request.autoScaling)) {
|
|
8159
8994
|
body["auto_scaling"] = request.autoScaling;
|
|
8160
8995
|
}
|
|
8161
8996
|
if (!tea_util_1.default.isUnset(request.count)) {
|
|
8162
8997
|
body["count"] = request.count;
|
|
8163
8998
|
}
|
|
8164
|
-
if (!tea_util_1.default.isUnset(
|
|
8999
|
+
if (!tea_util_1.default.isUnset(request.interconnectConfig)) {
|
|
8165
9000
|
body["interconnect_config"] = request.interconnectConfig;
|
|
8166
9001
|
}
|
|
8167
9002
|
if (!tea_util_1.default.isUnset(request.interconnectMode)) {
|
|
8168
9003
|
body["interconnect_mode"] = request.interconnectMode;
|
|
8169
9004
|
}
|
|
8170
|
-
if (!tea_util_1.default.isUnset(
|
|
9005
|
+
if (!tea_util_1.default.isUnset(request.kubernetesConfig)) {
|
|
8171
9006
|
body["kubernetes_config"] = request.kubernetesConfig;
|
|
8172
9007
|
}
|
|
8173
|
-
if (!tea_util_1.default.isUnset(
|
|
9008
|
+
if (!tea_util_1.default.isUnset(request.management)) {
|
|
8174
9009
|
body["management"] = request.management;
|
|
8175
9010
|
}
|
|
8176
9011
|
if (!tea_util_1.default.isUnset(request.maxNodes)) {
|
|
8177
9012
|
body["max_nodes"] = request.maxNodes;
|
|
8178
9013
|
}
|
|
8179
|
-
if (!tea_util_1.default.isUnset(
|
|
9014
|
+
if (!tea_util_1.default.isUnset(request.nodepoolInfo)) {
|
|
8180
9015
|
body["nodepool_info"] = request.nodepoolInfo;
|
|
8181
9016
|
}
|
|
8182
|
-
if (!tea_util_1.default.isUnset(
|
|
9017
|
+
if (!tea_util_1.default.isUnset(request.scalingGroup)) {
|
|
8183
9018
|
body["scaling_group"] = request.scalingGroup;
|
|
8184
9019
|
}
|
|
8185
|
-
if (!tea_util_1.default.isUnset(
|
|
9020
|
+
if (!tea_util_1.default.isUnset(request.teeConfig)) {
|
|
8186
9021
|
body["tee_config"] = request.teeConfig;
|
|
8187
9022
|
}
|
|
8188
9023
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -8202,10 +9037,10 @@ class Client extends openapi_client_1.default {
|
|
|
8202
9037
|
});
|
|
8203
9038
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateClusterNodePoolResponse({}));
|
|
8204
9039
|
}
|
|
8205
|
-
async
|
|
9040
|
+
async createClusterNodePool(ClusterId, request) {
|
|
8206
9041
|
let runtime = new $Util.RuntimeOptions({});
|
|
8207
9042
|
let headers = {};
|
|
8208
|
-
return await this.
|
|
9043
|
+
return await this.createClusterNodePoolWithOptions(ClusterId, request, headers, runtime);
|
|
8209
9044
|
}
|
|
8210
9045
|
async createEdgeMachineWithOptions(request, headers, runtime) {
|
|
8211
9046
|
tea_util_1.default.validateModel(request);
|
|
@@ -8236,10 +9071,10 @@ class Client extends openapi_client_1.default {
|
|
|
8236
9071
|
});
|
|
8237
9072
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateEdgeMachineResponse({}));
|
|
8238
9073
|
}
|
|
8239
|
-
async
|
|
9074
|
+
async createEdgeMachine(request) {
|
|
8240
9075
|
let runtime = new $Util.RuntimeOptions({});
|
|
8241
9076
|
let headers = {};
|
|
8242
|
-
return await this.
|
|
9077
|
+
return await this.createEdgeMachineWithOptions(request, headers, runtime);
|
|
8243
9078
|
}
|
|
8244
9079
|
async createKubernetesTriggerWithOptions(request, headers, runtime) {
|
|
8245
9080
|
tea_util_1.default.validateModel(request);
|
|
@@ -8273,10 +9108,10 @@ class Client extends openapi_client_1.default {
|
|
|
8273
9108
|
});
|
|
8274
9109
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateKubernetesTriggerResponse({}));
|
|
8275
9110
|
}
|
|
8276
|
-
async
|
|
9111
|
+
async createKubernetesTrigger(request) {
|
|
8277
9112
|
let runtime = new $Util.RuntimeOptions({});
|
|
8278
9113
|
let headers = {};
|
|
8279
|
-
return await this.
|
|
9114
|
+
return await this.createKubernetesTriggerWithOptions(request, headers, runtime);
|
|
8280
9115
|
}
|
|
8281
9116
|
async createTemplateWithOptions(request, headers, runtime) {
|
|
8282
9117
|
tea_util_1.default.validateModel(request);
|
|
@@ -8313,10 +9148,10 @@ class Client extends openapi_client_1.default {
|
|
|
8313
9148
|
});
|
|
8314
9149
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateTemplateResponse({}));
|
|
8315
9150
|
}
|
|
8316
|
-
async
|
|
9151
|
+
async createTemplate(request) {
|
|
8317
9152
|
let runtime = new $Util.RuntimeOptions({});
|
|
8318
9153
|
let headers = {};
|
|
8319
|
-
return await this.
|
|
9154
|
+
return await this.createTemplateWithOptions(request, headers, runtime);
|
|
8320
9155
|
}
|
|
8321
9156
|
async createTriggerWithOptions(clusterId, request, headers, runtime) {
|
|
8322
9157
|
tea_util_1.default.validateModel(request);
|
|
@@ -8350,10 +9185,10 @@ class Client extends openapi_client_1.default {
|
|
|
8350
9185
|
});
|
|
8351
9186
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateTriggerResponse({}));
|
|
8352
9187
|
}
|
|
8353
|
-
async
|
|
9188
|
+
async createTrigger(clusterId, request) {
|
|
8354
9189
|
let runtime = new $Util.RuntimeOptions({});
|
|
8355
9190
|
let headers = {};
|
|
8356
|
-
return await this.
|
|
9191
|
+
return await this.createTriggerWithOptions(clusterId, request, headers, runtime);
|
|
8357
9192
|
}
|
|
8358
9193
|
async deleteAlertContactWithOptions(headers, runtime) {
|
|
8359
9194
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -8372,10 +9207,10 @@ class Client extends openapi_client_1.default {
|
|
|
8372
9207
|
});
|
|
8373
9208
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteAlertContactResponse({}));
|
|
8374
9209
|
}
|
|
8375
|
-
async
|
|
9210
|
+
async deleteAlertContact() {
|
|
8376
9211
|
let runtime = new $Util.RuntimeOptions({});
|
|
8377
9212
|
let headers = {};
|
|
8378
|
-
return await this.
|
|
9213
|
+
return await this.deleteAlertContactWithOptions(headers, runtime);
|
|
8379
9214
|
}
|
|
8380
9215
|
async deleteAlertContactGroupWithOptions(headers, runtime) {
|
|
8381
9216
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -8394,10 +9229,10 @@ class Client extends openapi_client_1.default {
|
|
|
8394
9229
|
});
|
|
8395
9230
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteAlertContactGroupResponse({}));
|
|
8396
9231
|
}
|
|
8397
|
-
async
|
|
9232
|
+
async deleteAlertContactGroup() {
|
|
8398
9233
|
let runtime = new $Util.RuntimeOptions({});
|
|
8399
9234
|
let headers = {};
|
|
8400
|
-
return await this.
|
|
9235
|
+
return await this.deleteAlertContactGroupWithOptions(headers, runtime);
|
|
8401
9236
|
}
|
|
8402
9237
|
async deleteClusterWithOptions(ClusterId, tmpReq, headers, runtime) {
|
|
8403
9238
|
tea_util_1.default.validateModel(tmpReq);
|
|
@@ -8429,14 +9264,14 @@ class Client extends openapi_client_1.default {
|
|
|
8429
9264
|
authType: "AK",
|
|
8430
9265
|
style: "ROA",
|
|
8431
9266
|
reqBodyType: "json",
|
|
8432
|
-
bodyType: "
|
|
9267
|
+
bodyType: "json",
|
|
8433
9268
|
});
|
|
8434
9269
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteClusterResponse({}));
|
|
8435
9270
|
}
|
|
8436
|
-
async
|
|
9271
|
+
async deleteCluster(ClusterId, request) {
|
|
8437
9272
|
let runtime = new $Util.RuntimeOptions({});
|
|
8438
9273
|
let headers = {};
|
|
8439
|
-
return await this.
|
|
9274
|
+
return await this.deleteClusterWithOptions(ClusterId, request, headers, runtime);
|
|
8440
9275
|
}
|
|
8441
9276
|
async deleteClusterNodepoolWithOptions(ClusterId, NodepoolId, request, headers, runtime) {
|
|
8442
9277
|
tea_util_1.default.validateModel(request);
|
|
@@ -8461,11 +9296,23 @@ class Client extends openapi_client_1.default {
|
|
|
8461
9296
|
});
|
|
8462
9297
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteClusterNodepoolResponse({}));
|
|
8463
9298
|
}
|
|
8464
|
-
async
|
|
9299
|
+
async deleteClusterNodepool(ClusterId, NodepoolId, request) {
|
|
8465
9300
|
let runtime = new $Util.RuntimeOptions({});
|
|
8466
9301
|
let headers = {};
|
|
8467
|
-
return await this.
|
|
9302
|
+
return await this.deleteClusterNodepoolWithOptions(ClusterId, NodepoolId, request, headers, runtime);
|
|
8468
9303
|
}
|
|
9304
|
+
/**
|
|
9305
|
+
* >
|
|
9306
|
+
* * When you remove a node, the pods that run on the node are migrated to other nodes. This may cause service interruptions. We recommend that you remove nodes during off-peak hours.
|
|
9307
|
+
* * Unknown errors may occur when you remove nodes. Before you remove nodes, back up the data on the nodes.
|
|
9308
|
+
* * Nodes remain in the unschedulable state when they are being removed.
|
|
9309
|
+
* * You can remove only worker nodes by calling this operation.
|
|
9310
|
+
*
|
|
9311
|
+
* @param request DeleteClusterNodesRequest
|
|
9312
|
+
* @param headers map
|
|
9313
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
9314
|
+
* @return DeleteClusterNodesResponse
|
|
9315
|
+
*/
|
|
8469
9316
|
async deleteClusterNodesWithOptions(ClusterId, request, headers, runtime) {
|
|
8470
9317
|
tea_util_1.default.validateModel(request);
|
|
8471
9318
|
let body = {};
|
|
@@ -8495,10 +9342,20 @@ class Client extends openapi_client_1.default {
|
|
|
8495
9342
|
});
|
|
8496
9343
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteClusterNodesResponse({}));
|
|
8497
9344
|
}
|
|
8498
|
-
|
|
9345
|
+
/**
|
|
9346
|
+
* >
|
|
9347
|
+
* * When you remove a node, the pods that run on the node are migrated to other nodes. This may cause service interruptions. We recommend that you remove nodes during off-peak hours.
|
|
9348
|
+
* * Unknown errors may occur when you remove nodes. Before you remove nodes, back up the data on the nodes.
|
|
9349
|
+
* * Nodes remain in the unschedulable state when they are being removed.
|
|
9350
|
+
* * You can remove only worker nodes by calling this operation.
|
|
9351
|
+
*
|
|
9352
|
+
* @param request DeleteClusterNodesRequest
|
|
9353
|
+
* @return DeleteClusterNodesResponse
|
|
9354
|
+
*/
|
|
9355
|
+
async deleteClusterNodes(ClusterId, request) {
|
|
8499
9356
|
let runtime = new $Util.RuntimeOptions({});
|
|
8500
9357
|
let headers = {};
|
|
8501
|
-
return await this.
|
|
9358
|
+
return await this.deleteClusterNodesWithOptions(ClusterId, request, headers, runtime);
|
|
8502
9359
|
}
|
|
8503
9360
|
async deleteEdgeMachineWithOptions(edgeMachineid, request, headers, runtime) {
|
|
8504
9361
|
tea_util_1.default.validateModel(request);
|
|
@@ -8523,10 +9380,10 @@ class Client extends openapi_client_1.default {
|
|
|
8523
9380
|
});
|
|
8524
9381
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteEdgeMachineResponse({}));
|
|
8525
9382
|
}
|
|
8526
|
-
async
|
|
9383
|
+
async deleteEdgeMachine(edgeMachineid, request) {
|
|
8527
9384
|
let runtime = new $Util.RuntimeOptions({});
|
|
8528
9385
|
let headers = {};
|
|
8529
|
-
return await this.
|
|
9386
|
+
return await this.deleteEdgeMachineWithOptions(edgeMachineid, request, headers, runtime);
|
|
8530
9387
|
}
|
|
8531
9388
|
async deleteKubernetesTriggerWithOptions(Id, headers, runtime) {
|
|
8532
9389
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -8545,10 +9402,10 @@ class Client extends openapi_client_1.default {
|
|
|
8545
9402
|
});
|
|
8546
9403
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteKubernetesTriggerResponse({}));
|
|
8547
9404
|
}
|
|
8548
|
-
async
|
|
9405
|
+
async deleteKubernetesTrigger(Id) {
|
|
8549
9406
|
let runtime = new $Util.RuntimeOptions({});
|
|
8550
9407
|
let headers = {};
|
|
8551
|
-
return await this.
|
|
9408
|
+
return await this.deleteKubernetesTriggerWithOptions(Id, headers, runtime);
|
|
8552
9409
|
}
|
|
8553
9410
|
async deletePolicyInstanceWithOptions(clusterId, policyName, request, headers, runtime) {
|
|
8554
9411
|
tea_util_1.default.validateModel(request);
|
|
@@ -8573,10 +9430,10 @@ class Client extends openapi_client_1.default {
|
|
|
8573
9430
|
});
|
|
8574
9431
|
return $tea.cast(await this.callApi(params, req, runtime), new DeletePolicyInstanceResponse({}));
|
|
8575
9432
|
}
|
|
8576
|
-
async
|
|
9433
|
+
async deletePolicyInstance(clusterId, policyName, request) {
|
|
8577
9434
|
let runtime = new $Util.RuntimeOptions({});
|
|
8578
9435
|
let headers = {};
|
|
8579
|
-
return await this.
|
|
9436
|
+
return await this.deletePolicyInstanceWithOptions(clusterId, policyName, request, headers, runtime);
|
|
8580
9437
|
}
|
|
8581
9438
|
async deleteTemplateWithOptions(TemplateId, headers, runtime) {
|
|
8582
9439
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -8595,10 +9452,10 @@ class Client extends openapi_client_1.default {
|
|
|
8595
9452
|
});
|
|
8596
9453
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteTemplateResponse({}));
|
|
8597
9454
|
}
|
|
8598
|
-
async
|
|
9455
|
+
async deleteTemplate(TemplateId) {
|
|
8599
9456
|
let runtime = new $Util.RuntimeOptions({});
|
|
8600
9457
|
let headers = {};
|
|
8601
|
-
return await this.
|
|
9458
|
+
return await this.deleteTemplateWithOptions(TemplateId, headers, runtime);
|
|
8602
9459
|
}
|
|
8603
9460
|
async deleteTriggerWithOptions(clusterId, Id, headers, runtime) {
|
|
8604
9461
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -8617,10 +9474,10 @@ class Client extends openapi_client_1.default {
|
|
|
8617
9474
|
});
|
|
8618
9475
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteTriggerResponse({}));
|
|
8619
9476
|
}
|
|
8620
|
-
async
|
|
9477
|
+
async deleteTrigger(clusterId, Id) {
|
|
8621
9478
|
let runtime = new $Util.RuntimeOptions({});
|
|
8622
9479
|
let headers = {};
|
|
8623
|
-
return await this.
|
|
9480
|
+
return await this.deleteTriggerWithOptions(clusterId, Id, headers, runtime);
|
|
8624
9481
|
}
|
|
8625
9482
|
async deployPolicyInstanceWithOptions(clusterId, policyName, request, headers, runtime) {
|
|
8626
9483
|
tea_util_1.default.validateModel(request);
|
|
@@ -8651,10 +9508,10 @@ class Client extends openapi_client_1.default {
|
|
|
8651
9508
|
});
|
|
8652
9509
|
return $tea.cast(await this.callApi(params, req, runtime), new DeployPolicyInstanceResponse({}));
|
|
8653
9510
|
}
|
|
8654
|
-
async
|
|
9511
|
+
async deployPolicyInstance(clusterId, policyName, request) {
|
|
8655
9512
|
let runtime = new $Util.RuntimeOptions({});
|
|
8656
9513
|
let headers = {};
|
|
8657
|
-
return await this.
|
|
9514
|
+
return await this.deployPolicyInstanceWithOptions(clusterId, policyName, request, headers, runtime);
|
|
8658
9515
|
}
|
|
8659
9516
|
async descirbeWorkflowWithOptions(workflowName, headers, runtime) {
|
|
8660
9517
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -8673,17 +9530,26 @@ class Client extends openapi_client_1.default {
|
|
|
8673
9530
|
});
|
|
8674
9531
|
return $tea.cast(await this.callApi(params, req, runtime), new DescirbeWorkflowResponse({}));
|
|
8675
9532
|
}
|
|
8676
|
-
async
|
|
9533
|
+
async descirbeWorkflow(workflowName) {
|
|
8677
9534
|
let runtime = new $Util.RuntimeOptions({});
|
|
8678
9535
|
let headers = {};
|
|
8679
|
-
return await this.
|
|
9536
|
+
return await this.descirbeWorkflowWithOptions(workflowName, headers, runtime);
|
|
8680
9537
|
}
|
|
8681
9538
|
async describeAddonsWithOptions(request, headers, runtime) {
|
|
8682
9539
|
tea_util_1.default.validateModel(request);
|
|
8683
9540
|
let query = {};
|
|
9541
|
+
if (!tea_util_1.default.isUnset(request.clusterProfile)) {
|
|
9542
|
+
query["cluster_profile"] = request.clusterProfile;
|
|
9543
|
+
}
|
|
9544
|
+
if (!tea_util_1.default.isUnset(request.clusterSpec)) {
|
|
9545
|
+
query["cluster_spec"] = request.clusterSpec;
|
|
9546
|
+
}
|
|
8684
9547
|
if (!tea_util_1.default.isUnset(request.clusterType)) {
|
|
8685
9548
|
query["cluster_type"] = request.clusterType;
|
|
8686
9549
|
}
|
|
9550
|
+
if (!tea_util_1.default.isUnset(request.clusterVersion)) {
|
|
9551
|
+
query["cluster_version"] = request.clusterVersion;
|
|
9552
|
+
}
|
|
8687
9553
|
if (!tea_util_1.default.isUnset(request.region)) {
|
|
8688
9554
|
query["region"] = request.region;
|
|
8689
9555
|
}
|
|
@@ -8704,10 +9570,32 @@ class Client extends openapi_client_1.default {
|
|
|
8704
9570
|
});
|
|
8705
9571
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeAddonsResponse({}));
|
|
8706
9572
|
}
|
|
8707
|
-
async
|
|
9573
|
+
async describeAddons(request) {
|
|
8708
9574
|
let runtime = new $Util.RuntimeOptions({});
|
|
8709
9575
|
let headers = {};
|
|
8710
|
-
return await this.
|
|
9576
|
+
return await this.describeAddonsWithOptions(request, headers, runtime);
|
|
9577
|
+
}
|
|
9578
|
+
async describeClusterAddonInstanceWithOptions(ClusterID, AddonName, headers, runtime) {
|
|
9579
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
9580
|
+
headers: headers,
|
|
9581
|
+
});
|
|
9582
|
+
let params = new $OpenApi.Params({
|
|
9583
|
+
action: "DescribeClusterAddonInstance",
|
|
9584
|
+
version: "2015-12-15",
|
|
9585
|
+
protocol: "HTTPS",
|
|
9586
|
+
pathname: `/clusters/${openapi_util_1.default.getEncodeParam(ClusterID)}/components/${openapi_util_1.default.getEncodeParam(AddonName)}/instance`,
|
|
9587
|
+
method: "GET",
|
|
9588
|
+
authType: "AK",
|
|
9589
|
+
style: "ROA",
|
|
9590
|
+
reqBodyType: "json",
|
|
9591
|
+
bodyType: "json",
|
|
9592
|
+
});
|
|
9593
|
+
return $tea.cast(await this.callApi(params, req, runtime), new DescribeClusterAddonInstanceResponse({}));
|
|
9594
|
+
}
|
|
9595
|
+
async describeClusterAddonInstance(ClusterID, AddonName) {
|
|
9596
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
9597
|
+
let headers = {};
|
|
9598
|
+
return await this.describeClusterAddonInstanceWithOptions(ClusterID, AddonName, headers, runtime);
|
|
8711
9599
|
}
|
|
8712
9600
|
async describeClusterAddonMetadataWithOptions(clusterId, componentId, version, headers, runtime) {
|
|
8713
9601
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -8726,11 +9614,19 @@ class Client extends openapi_client_1.default {
|
|
|
8726
9614
|
});
|
|
8727
9615
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeClusterAddonMetadataResponse({}));
|
|
8728
9616
|
}
|
|
8729
|
-
async
|
|
9617
|
+
async describeClusterAddonMetadata(clusterId, componentId, version) {
|
|
8730
9618
|
let runtime = new $Util.RuntimeOptions({});
|
|
8731
9619
|
let headers = {};
|
|
8732
|
-
return await this.
|
|
9620
|
+
return await this.describeClusterAddonMetadataWithOptions(clusterId, componentId, version, headers, runtime);
|
|
8733
9621
|
}
|
|
9622
|
+
/**
|
|
9623
|
+
* @deprecated
|
|
9624
|
+
*
|
|
9625
|
+
* @param headers map
|
|
9626
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
9627
|
+
* @return DescribeClusterAddonUpgradeStatusResponse
|
|
9628
|
+
*/
|
|
9629
|
+
// Deprecated
|
|
8734
9630
|
async describeClusterAddonUpgradeStatusWithOptions(ClusterId, ComponentId, headers, runtime) {
|
|
8735
9631
|
let req = new $OpenApi.OpenApiRequest({
|
|
8736
9632
|
headers: headers,
|
|
@@ -8748,10 +9644,16 @@ class Client extends openapi_client_1.default {
|
|
|
8748
9644
|
});
|
|
8749
9645
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeClusterAddonUpgradeStatusResponse({}));
|
|
8750
9646
|
}
|
|
8751
|
-
|
|
9647
|
+
/**
|
|
9648
|
+
* @deprecated
|
|
9649
|
+
*
|
|
9650
|
+
* @return DescribeClusterAddonUpgradeStatusResponse
|
|
9651
|
+
*/
|
|
9652
|
+
// Deprecated
|
|
9653
|
+
async describeClusterAddonUpgradeStatus(ClusterId, ComponentId) {
|
|
8752
9654
|
let runtime = new $Util.RuntimeOptions({});
|
|
8753
9655
|
let headers = {};
|
|
8754
|
-
return await this.
|
|
9656
|
+
return await this.describeClusterAddonUpgradeStatusWithOptions(ClusterId, ComponentId, headers, runtime);
|
|
8755
9657
|
}
|
|
8756
9658
|
async describeClusterAddonsUpgradeStatusWithOptions(ClusterId, tmpReq, headers, runtime) {
|
|
8757
9659
|
tea_util_1.default.validateModel(tmpReq);
|
|
@@ -8781,10 +9683,10 @@ class Client extends openapi_client_1.default {
|
|
|
8781
9683
|
});
|
|
8782
9684
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeClusterAddonsUpgradeStatusResponse({}));
|
|
8783
9685
|
}
|
|
8784
|
-
async
|
|
9686
|
+
async describeClusterAddonsUpgradeStatus(ClusterId, request) {
|
|
8785
9687
|
let runtime = new $Util.RuntimeOptions({});
|
|
8786
9688
|
let headers = {};
|
|
8787
|
-
return await this.
|
|
9689
|
+
return await this.describeClusterAddonsUpgradeStatusWithOptions(ClusterId, request, headers, runtime);
|
|
8788
9690
|
}
|
|
8789
9691
|
async describeClusterAddonsVersionWithOptions(ClusterId, headers, runtime) {
|
|
8790
9692
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -8803,10 +9705,10 @@ class Client extends openapi_client_1.default {
|
|
|
8803
9705
|
});
|
|
8804
9706
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeClusterAddonsVersionResponse({}));
|
|
8805
9707
|
}
|
|
8806
|
-
async
|
|
9708
|
+
async describeClusterAddonsVersion(ClusterId) {
|
|
8807
9709
|
let runtime = new $Util.RuntimeOptions({});
|
|
8808
9710
|
let headers = {};
|
|
8809
|
-
return await this.
|
|
9711
|
+
return await this.describeClusterAddonsVersionWithOptions(ClusterId, headers, runtime);
|
|
8810
9712
|
}
|
|
8811
9713
|
async describeClusterAttachScriptsWithOptions(ClusterId, request, headers, runtime) {
|
|
8812
9714
|
tea_util_1.default.validateModel(request);
|
|
@@ -8846,10 +9748,10 @@ class Client extends openapi_client_1.default {
|
|
|
8846
9748
|
});
|
|
8847
9749
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeClusterAttachScriptsResponse({}));
|
|
8848
9750
|
}
|
|
8849
|
-
async
|
|
9751
|
+
async describeClusterAttachScripts(ClusterId, request) {
|
|
8850
9752
|
let runtime = new $Util.RuntimeOptions({});
|
|
8851
9753
|
let headers = {};
|
|
8852
|
-
return await this.
|
|
9754
|
+
return await this.describeClusterAttachScriptsWithOptions(ClusterId, request, headers, runtime);
|
|
8853
9755
|
}
|
|
8854
9756
|
async describeClusterDetailWithOptions(ClusterId, headers, runtime) {
|
|
8855
9757
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -8868,10 +9770,10 @@ class Client extends openapi_client_1.default {
|
|
|
8868
9770
|
});
|
|
8869
9771
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeClusterDetailResponse({}));
|
|
8870
9772
|
}
|
|
8871
|
-
async
|
|
9773
|
+
async describeClusterDetail(ClusterId) {
|
|
8872
9774
|
let runtime = new $Util.RuntimeOptions({});
|
|
8873
9775
|
let headers = {};
|
|
8874
|
-
return await this.
|
|
9776
|
+
return await this.describeClusterDetailWithOptions(ClusterId, headers, runtime);
|
|
8875
9777
|
}
|
|
8876
9778
|
async describeClusterEventsWithOptions(ClusterId, request, headers, runtime) {
|
|
8877
9779
|
tea_util_1.default.validateModel(request);
|
|
@@ -8902,10 +9804,10 @@ class Client extends openapi_client_1.default {
|
|
|
8902
9804
|
});
|
|
8903
9805
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeClusterEventsResponse({}));
|
|
8904
9806
|
}
|
|
8905
|
-
async
|
|
9807
|
+
async describeClusterEvents(ClusterId, request) {
|
|
8906
9808
|
let runtime = new $Util.RuntimeOptions({});
|
|
8907
9809
|
let headers = {};
|
|
8908
|
-
return await this.
|
|
9810
|
+
return await this.describeClusterEventsWithOptions(ClusterId, request, headers, runtime);
|
|
8909
9811
|
}
|
|
8910
9812
|
async describeClusterLogsWithOptions(ClusterId, headers, runtime) {
|
|
8911
9813
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -8924,10 +9826,10 @@ class Client extends openapi_client_1.default {
|
|
|
8924
9826
|
});
|
|
8925
9827
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeClusterLogsResponse({}));
|
|
8926
9828
|
}
|
|
8927
|
-
async
|
|
9829
|
+
async describeClusterLogs(ClusterId) {
|
|
8928
9830
|
let runtime = new $Util.RuntimeOptions({});
|
|
8929
9831
|
let headers = {};
|
|
8930
|
-
return await this.
|
|
9832
|
+
return await this.describeClusterLogsWithOptions(ClusterId, headers, runtime);
|
|
8931
9833
|
}
|
|
8932
9834
|
async describeClusterNodePoolDetailWithOptions(ClusterId, NodepoolId, headers, runtime) {
|
|
8933
9835
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -8946,10 +9848,10 @@ class Client extends openapi_client_1.default {
|
|
|
8946
9848
|
});
|
|
8947
9849
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeClusterNodePoolDetailResponse({}));
|
|
8948
9850
|
}
|
|
8949
|
-
async
|
|
9851
|
+
async describeClusterNodePoolDetail(ClusterId, NodepoolId) {
|
|
8950
9852
|
let runtime = new $Util.RuntimeOptions({});
|
|
8951
9853
|
let headers = {};
|
|
8952
|
-
return await this.
|
|
9854
|
+
return await this.describeClusterNodePoolDetailWithOptions(ClusterId, NodepoolId, headers, runtime);
|
|
8953
9855
|
}
|
|
8954
9856
|
async describeClusterNodePoolsWithOptions(ClusterId, headers, runtime) {
|
|
8955
9857
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -8968,10 +9870,10 @@ class Client extends openapi_client_1.default {
|
|
|
8968
9870
|
});
|
|
8969
9871
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeClusterNodePoolsResponse({}));
|
|
8970
9872
|
}
|
|
8971
|
-
async
|
|
9873
|
+
async describeClusterNodePools(ClusterId) {
|
|
8972
9874
|
let runtime = new $Util.RuntimeOptions({});
|
|
8973
9875
|
let headers = {};
|
|
8974
|
-
return await this.
|
|
9876
|
+
return await this.describeClusterNodePoolsWithOptions(ClusterId, headers, runtime);
|
|
8975
9877
|
}
|
|
8976
9878
|
async describeClusterNodesWithOptions(ClusterId, request, headers, runtime) {
|
|
8977
9879
|
tea_util_1.default.validateModel(request);
|
|
@@ -9008,10 +9910,10 @@ class Client extends openapi_client_1.default {
|
|
|
9008
9910
|
});
|
|
9009
9911
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeClusterNodesResponse({}));
|
|
9010
9912
|
}
|
|
9011
|
-
async
|
|
9913
|
+
async describeClusterNodes(ClusterId, request) {
|
|
9012
9914
|
let runtime = new $Util.RuntimeOptions({});
|
|
9013
9915
|
let headers = {};
|
|
9014
|
-
return await this.
|
|
9916
|
+
return await this.describeClusterNodesWithOptions(ClusterId, request, headers, runtime);
|
|
9015
9917
|
}
|
|
9016
9918
|
async describeClusterResourcesWithOptions(ClusterId, headers, runtime) {
|
|
9017
9919
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -9030,10 +9932,10 @@ class Client extends openapi_client_1.default {
|
|
|
9030
9932
|
});
|
|
9031
9933
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeClusterResourcesResponse({}));
|
|
9032
9934
|
}
|
|
9033
|
-
async
|
|
9935
|
+
async describeClusterResources(ClusterId) {
|
|
9034
9936
|
let runtime = new $Util.RuntimeOptions({});
|
|
9035
9937
|
let headers = {};
|
|
9036
|
-
return await this.
|
|
9938
|
+
return await this.describeClusterResourcesWithOptions(ClusterId, headers, runtime);
|
|
9037
9939
|
}
|
|
9038
9940
|
async describeClusterTasksWithOptions(clusterId, headers, runtime) {
|
|
9039
9941
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -9052,10 +9954,10 @@ class Client extends openapi_client_1.default {
|
|
|
9052
9954
|
});
|
|
9053
9955
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeClusterTasksResponse({}));
|
|
9054
9956
|
}
|
|
9055
|
-
async
|
|
9957
|
+
async describeClusterTasks(clusterId) {
|
|
9056
9958
|
let runtime = new $Util.RuntimeOptions({});
|
|
9057
9959
|
let headers = {};
|
|
9058
|
-
return await this.
|
|
9960
|
+
return await this.describeClusterTasksWithOptions(clusterId, headers, runtime);
|
|
9059
9961
|
}
|
|
9060
9962
|
async describeClusterUserKubeconfigWithOptions(ClusterId, request, headers, runtime) {
|
|
9061
9963
|
tea_util_1.default.validateModel(request);
|
|
@@ -9083,11 +9985,20 @@ class Client extends openapi_client_1.default {
|
|
|
9083
9985
|
});
|
|
9084
9986
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeClusterUserKubeconfigResponse({}));
|
|
9085
9987
|
}
|
|
9086
|
-
async
|
|
9988
|
+
async describeClusterUserKubeconfig(ClusterId, request) {
|
|
9087
9989
|
let runtime = new $Util.RuntimeOptions({});
|
|
9088
9990
|
let headers = {};
|
|
9089
|
-
return await this.
|
|
9991
|
+
return await this.describeClusterUserKubeconfigWithOptions(ClusterId, request, headers, runtime);
|
|
9090
9992
|
}
|
|
9993
|
+
/**
|
|
9994
|
+
* @deprecated
|
|
9995
|
+
*
|
|
9996
|
+
* @param request DescribeClusterV2UserKubeconfigRequest
|
|
9997
|
+
* @param headers map
|
|
9998
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
9999
|
+
* @return DescribeClusterV2UserKubeconfigResponse
|
|
10000
|
+
*/
|
|
10001
|
+
// Deprecated
|
|
9091
10002
|
async describeClusterV2UserKubeconfigWithOptions(ClusterId, request, headers, runtime) {
|
|
9092
10003
|
tea_util_1.default.validateModel(request);
|
|
9093
10004
|
let query = {};
|
|
@@ -9111,11 +10022,49 @@ class Client extends openapi_client_1.default {
|
|
|
9111
10022
|
});
|
|
9112
10023
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeClusterV2UserKubeconfigResponse({}));
|
|
9113
10024
|
}
|
|
9114
|
-
|
|
10025
|
+
/**
|
|
10026
|
+
* @deprecated
|
|
10027
|
+
*
|
|
10028
|
+
* @param request DescribeClusterV2UserKubeconfigRequest
|
|
10029
|
+
* @return DescribeClusterV2UserKubeconfigResponse
|
|
10030
|
+
*/
|
|
10031
|
+
// Deprecated
|
|
10032
|
+
async describeClusterV2UserKubeconfig(ClusterId, request) {
|
|
9115
10033
|
let runtime = new $Util.RuntimeOptions({});
|
|
9116
10034
|
let headers = {};
|
|
9117
|
-
return await this.
|
|
10035
|
+
return await this.describeClusterV2UserKubeconfigWithOptions(ClusterId, request, headers, runtime);
|
|
10036
|
+
}
|
|
10037
|
+
async describeClusterVulsWithOptions(clusterId, headers, runtime) {
|
|
10038
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
10039
|
+
headers: headers,
|
|
10040
|
+
});
|
|
10041
|
+
let params = new $OpenApi.Params({
|
|
10042
|
+
action: "DescribeClusterVuls",
|
|
10043
|
+
version: "2015-12-15",
|
|
10044
|
+
protocol: "HTTPS",
|
|
10045
|
+
pathname: `/clusters/${openapi_util_1.default.getEncodeParam(clusterId)}/vuls`,
|
|
10046
|
+
method: "GET",
|
|
10047
|
+
authType: "AK",
|
|
10048
|
+
style: "ROA",
|
|
10049
|
+
reqBodyType: "json",
|
|
10050
|
+
bodyType: "json",
|
|
10051
|
+
});
|
|
10052
|
+
return $tea.cast(await this.callApi(params, req, runtime), new DescribeClusterVulsResponse({}));
|
|
9118
10053
|
}
|
|
10054
|
+
async describeClusterVuls(clusterId) {
|
|
10055
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
10056
|
+
let headers = {};
|
|
10057
|
+
return await this.describeClusterVulsWithOptions(clusterId, headers, runtime);
|
|
10058
|
+
}
|
|
10059
|
+
/**
|
|
10060
|
+
* @deprecated
|
|
10061
|
+
*
|
|
10062
|
+
* @param request DescribeClustersRequest
|
|
10063
|
+
* @param headers map
|
|
10064
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
10065
|
+
* @return DescribeClustersResponse
|
|
10066
|
+
*/
|
|
10067
|
+
// Deprecated
|
|
9119
10068
|
async describeClustersWithOptions(request, headers, runtime) {
|
|
9120
10069
|
tea_util_1.default.validateModel(request);
|
|
9121
10070
|
let query = {};
|
|
@@ -9142,10 +10091,17 @@ class Client extends openapi_client_1.default {
|
|
|
9142
10091
|
});
|
|
9143
10092
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeClustersResponse({}));
|
|
9144
10093
|
}
|
|
9145
|
-
|
|
10094
|
+
/**
|
|
10095
|
+
* @deprecated
|
|
10096
|
+
*
|
|
10097
|
+
* @param request DescribeClustersRequest
|
|
10098
|
+
* @return DescribeClustersResponse
|
|
10099
|
+
*/
|
|
10100
|
+
// Deprecated
|
|
10101
|
+
async describeClusters(request) {
|
|
9146
10102
|
let runtime = new $Util.RuntimeOptions({});
|
|
9147
10103
|
let headers = {};
|
|
9148
|
-
return await this.
|
|
10104
|
+
return await this.describeClustersWithOptions(request, headers, runtime);
|
|
9149
10105
|
}
|
|
9150
10106
|
async describeClustersV1WithOptions(request, headers, runtime) {
|
|
9151
10107
|
tea_util_1.default.validateModel(request);
|
|
@@ -9188,10 +10144,10 @@ class Client extends openapi_client_1.default {
|
|
|
9188
10144
|
});
|
|
9189
10145
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeClustersV1Response({}));
|
|
9190
10146
|
}
|
|
9191
|
-
async
|
|
10147
|
+
async describeClustersV1(request) {
|
|
9192
10148
|
let runtime = new $Util.RuntimeOptions({});
|
|
9193
10149
|
let headers = {};
|
|
9194
|
-
return await this.
|
|
10150
|
+
return await this.describeClustersV1WithOptions(request, headers, runtime);
|
|
9195
10151
|
}
|
|
9196
10152
|
async describeEdgeMachineActiveProcessWithOptions(edgeMachineid, headers, runtime) {
|
|
9197
10153
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -9210,10 +10166,10 @@ class Client extends openapi_client_1.default {
|
|
|
9210
10166
|
});
|
|
9211
10167
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeEdgeMachineActiveProcessResponse({}));
|
|
9212
10168
|
}
|
|
9213
|
-
async
|
|
10169
|
+
async describeEdgeMachineActiveProcess(edgeMachineid) {
|
|
9214
10170
|
let runtime = new $Util.RuntimeOptions({});
|
|
9215
10171
|
let headers = {};
|
|
9216
|
-
return await this.
|
|
10172
|
+
return await this.describeEdgeMachineActiveProcessWithOptions(edgeMachineid, headers, runtime);
|
|
9217
10173
|
}
|
|
9218
10174
|
async describeEdgeMachineModelsWithOptions(headers, runtime) {
|
|
9219
10175
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -9232,10 +10188,10 @@ class Client extends openapi_client_1.default {
|
|
|
9232
10188
|
});
|
|
9233
10189
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeEdgeMachineModelsResponse({}));
|
|
9234
10190
|
}
|
|
9235
|
-
async
|
|
10191
|
+
async describeEdgeMachineModels() {
|
|
9236
10192
|
let runtime = new $Util.RuntimeOptions({});
|
|
9237
10193
|
let headers = {};
|
|
9238
|
-
return await this.
|
|
10194
|
+
return await this.describeEdgeMachineModelsWithOptions(headers, runtime);
|
|
9239
10195
|
}
|
|
9240
10196
|
async describeEdgeMachineTunnelConfigDetailWithOptions(edgeMachineid, headers, runtime) {
|
|
9241
10197
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -9254,10 +10210,10 @@ class Client extends openapi_client_1.default {
|
|
|
9254
10210
|
});
|
|
9255
10211
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeEdgeMachineTunnelConfigDetailResponse({}));
|
|
9256
10212
|
}
|
|
9257
|
-
async
|
|
10213
|
+
async describeEdgeMachineTunnelConfigDetail(edgeMachineid) {
|
|
9258
10214
|
let runtime = new $Util.RuntimeOptions({});
|
|
9259
10215
|
let headers = {};
|
|
9260
|
-
return await this.
|
|
10216
|
+
return await this.describeEdgeMachineTunnelConfigDetailWithOptions(edgeMachineid, headers, runtime);
|
|
9261
10217
|
}
|
|
9262
10218
|
async describeEdgeMachinesWithOptions(request, headers, runtime) {
|
|
9263
10219
|
tea_util_1.default.validateModel(request);
|
|
@@ -9297,10 +10253,10 @@ class Client extends openapi_client_1.default {
|
|
|
9297
10253
|
});
|
|
9298
10254
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeEdgeMachinesResponse({}));
|
|
9299
10255
|
}
|
|
9300
|
-
async
|
|
10256
|
+
async describeEdgeMachines(request) {
|
|
9301
10257
|
let runtime = new $Util.RuntimeOptions({});
|
|
9302
10258
|
let headers = {};
|
|
9303
|
-
return await this.
|
|
10259
|
+
return await this.describeEdgeMachinesWithOptions(request, headers, runtime);
|
|
9304
10260
|
}
|
|
9305
10261
|
async describeEventsWithOptions(request, headers, runtime) {
|
|
9306
10262
|
tea_util_1.default.validateModel(request);
|
|
@@ -9334,11 +10290,19 @@ class Client extends openapi_client_1.default {
|
|
|
9334
10290
|
});
|
|
9335
10291
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeEventsResponse({}));
|
|
9336
10292
|
}
|
|
9337
|
-
async
|
|
10293
|
+
async describeEvents(request) {
|
|
9338
10294
|
let runtime = new $Util.RuntimeOptions({});
|
|
9339
10295
|
let headers = {};
|
|
9340
|
-
return await this.
|
|
10296
|
+
return await this.describeEventsWithOptions(request, headers, runtime);
|
|
9341
10297
|
}
|
|
10298
|
+
/**
|
|
10299
|
+
* For more information, see [Register an external Kubernetes cluster](~~121053~~).
|
|
10300
|
+
*
|
|
10301
|
+
* @param request DescribeExternalAgentRequest
|
|
10302
|
+
* @param headers map
|
|
10303
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
10304
|
+
* @return DescribeExternalAgentResponse
|
|
10305
|
+
*/
|
|
9342
10306
|
async describeExternalAgentWithOptions(ClusterId, request, headers, runtime) {
|
|
9343
10307
|
tea_util_1.default.validateModel(request);
|
|
9344
10308
|
let query = {};
|
|
@@ -9362,10 +10326,16 @@ class Client extends openapi_client_1.default {
|
|
|
9362
10326
|
});
|
|
9363
10327
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeExternalAgentResponse({}));
|
|
9364
10328
|
}
|
|
9365
|
-
|
|
10329
|
+
/**
|
|
10330
|
+
* For more information, see [Register an external Kubernetes cluster](~~121053~~).
|
|
10331
|
+
*
|
|
10332
|
+
* @param request DescribeExternalAgentRequest
|
|
10333
|
+
* @return DescribeExternalAgentResponse
|
|
10334
|
+
*/
|
|
10335
|
+
async describeExternalAgent(ClusterId, request) {
|
|
9366
10336
|
let runtime = new $Util.RuntimeOptions({});
|
|
9367
10337
|
let headers = {};
|
|
9368
|
-
return await this.
|
|
10338
|
+
return await this.describeExternalAgentWithOptions(ClusterId, request, headers, runtime);
|
|
9369
10339
|
}
|
|
9370
10340
|
async describeKubernetesVersionMetadataWithOptions(request, headers, runtime) {
|
|
9371
10341
|
tea_util_1.default.validateModel(request);
|
|
@@ -9376,6 +10346,9 @@ class Client extends openapi_client_1.default {
|
|
|
9376
10346
|
if (!tea_util_1.default.isUnset(request.kubernetesVersion)) {
|
|
9377
10347
|
query["KubernetesVersion"] = request.kubernetesVersion;
|
|
9378
10348
|
}
|
|
10349
|
+
if (!tea_util_1.default.isUnset(request.mode)) {
|
|
10350
|
+
query["Mode"] = request.mode;
|
|
10351
|
+
}
|
|
9379
10352
|
if (!tea_util_1.default.isUnset(request.profile)) {
|
|
9380
10353
|
query["Profile"] = request.profile;
|
|
9381
10354
|
}
|
|
@@ -9402,14 +10375,20 @@ class Client extends openapi_client_1.default {
|
|
|
9402
10375
|
});
|
|
9403
10376
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeKubernetesVersionMetadataResponse({}));
|
|
9404
10377
|
}
|
|
9405
|
-
async
|
|
10378
|
+
async describeKubernetesVersionMetadata(request) {
|
|
9406
10379
|
let runtime = new $Util.RuntimeOptions({});
|
|
9407
10380
|
let headers = {};
|
|
9408
|
-
return await this.
|
|
10381
|
+
return await this.describeKubernetesVersionMetadataWithOptions(request, headers, runtime);
|
|
9409
10382
|
}
|
|
9410
|
-
async describeNodePoolVulsWithOptions(clusterId, nodepoolId, headers, runtime) {
|
|
10383
|
+
async describeNodePoolVulsWithOptions(clusterId, nodepoolId, request, headers, runtime) {
|
|
10384
|
+
tea_util_1.default.validateModel(request);
|
|
10385
|
+
let query = {};
|
|
10386
|
+
if (!tea_util_1.default.isUnset(request.necessity)) {
|
|
10387
|
+
query["necessity"] = request.necessity;
|
|
10388
|
+
}
|
|
9411
10389
|
let req = new $OpenApi.OpenApiRequest({
|
|
9412
10390
|
headers: headers,
|
|
10391
|
+
query: openapi_util_1.default.query(query),
|
|
9413
10392
|
});
|
|
9414
10393
|
let params = new $OpenApi.Params({
|
|
9415
10394
|
action: "DescribeNodePoolVuls",
|
|
@@ -9424,10 +10403,10 @@ class Client extends openapi_client_1.default {
|
|
|
9424
10403
|
});
|
|
9425
10404
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeNodePoolVulsResponse({}));
|
|
9426
10405
|
}
|
|
9427
|
-
async
|
|
10406
|
+
async describeNodePoolVuls(clusterId, nodepoolId, request) {
|
|
9428
10407
|
let runtime = new $Util.RuntimeOptions({});
|
|
9429
10408
|
let headers = {};
|
|
9430
|
-
return await this.
|
|
10409
|
+
return await this.describeNodePoolVulsWithOptions(clusterId, nodepoolId, request, headers, runtime);
|
|
9431
10410
|
}
|
|
9432
10411
|
async describePoliciesWithOptions(headers, runtime) {
|
|
9433
10412
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -9446,10 +10425,10 @@ class Client extends openapi_client_1.default {
|
|
|
9446
10425
|
});
|
|
9447
10426
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribePoliciesResponse({}));
|
|
9448
10427
|
}
|
|
9449
|
-
async
|
|
10428
|
+
async describePolicies() {
|
|
9450
10429
|
let runtime = new $Util.RuntimeOptions({});
|
|
9451
10430
|
let headers = {};
|
|
9452
|
-
return await this.
|
|
10431
|
+
return await this.describePoliciesWithOptions(headers, runtime);
|
|
9453
10432
|
}
|
|
9454
10433
|
async describePolicyDetailsWithOptions(policyName, headers, runtime) {
|
|
9455
10434
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -9468,10 +10447,10 @@ class Client extends openapi_client_1.default {
|
|
|
9468
10447
|
});
|
|
9469
10448
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribePolicyDetailsResponse({}));
|
|
9470
10449
|
}
|
|
9471
|
-
async
|
|
10450
|
+
async describePolicyDetails(policyName) {
|
|
9472
10451
|
let runtime = new $Util.RuntimeOptions({});
|
|
9473
10452
|
let headers = {};
|
|
9474
|
-
return await this.
|
|
10453
|
+
return await this.describePolicyDetailsWithOptions(policyName, headers, runtime);
|
|
9475
10454
|
}
|
|
9476
10455
|
async describePolicyGovernanceInClusterWithOptions(clusterId, headers, runtime) {
|
|
9477
10456
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -9490,10 +10469,10 @@ class Client extends openapi_client_1.default {
|
|
|
9490
10469
|
});
|
|
9491
10470
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribePolicyGovernanceInClusterResponse({}));
|
|
9492
10471
|
}
|
|
9493
|
-
async
|
|
10472
|
+
async describePolicyGovernanceInCluster(clusterId) {
|
|
9494
10473
|
let runtime = new $Util.RuntimeOptions({});
|
|
9495
10474
|
let headers = {};
|
|
9496
|
-
return await this.
|
|
10475
|
+
return await this.describePolicyGovernanceInClusterWithOptions(clusterId, headers, runtime);
|
|
9497
10476
|
}
|
|
9498
10477
|
async describePolicyInstancesWithOptions(clusterId, request, headers, runtime) {
|
|
9499
10478
|
tea_util_1.default.validateModel(request);
|
|
@@ -9521,10 +10500,10 @@ class Client extends openapi_client_1.default {
|
|
|
9521
10500
|
});
|
|
9522
10501
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribePolicyInstancesResponse({}));
|
|
9523
10502
|
}
|
|
9524
|
-
async
|
|
10503
|
+
async describePolicyInstances(clusterId, request) {
|
|
9525
10504
|
let runtime = new $Util.RuntimeOptions({});
|
|
9526
10505
|
let headers = {};
|
|
9527
|
-
return await this.
|
|
10506
|
+
return await this.describePolicyInstancesWithOptions(clusterId, request, headers, runtime);
|
|
9528
10507
|
}
|
|
9529
10508
|
async describePolicyInstancesStatusWithOptions(clusterId, headers, runtime) {
|
|
9530
10509
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -9543,10 +10522,55 @@ class Client extends openapi_client_1.default {
|
|
|
9543
10522
|
});
|
|
9544
10523
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribePolicyInstancesStatusResponse({}));
|
|
9545
10524
|
}
|
|
9546
|
-
async
|
|
10525
|
+
async describePolicyInstancesStatus(clusterId) {
|
|
9547
10526
|
let runtime = new $Util.RuntimeOptions({});
|
|
9548
10527
|
let headers = {};
|
|
9549
|
-
return await this.
|
|
10528
|
+
return await this.describePolicyInstancesStatusWithOptions(clusterId, headers, runtime);
|
|
10529
|
+
}
|
|
10530
|
+
/**
|
|
10531
|
+
* > You can call this operation only with an Alibaba Cloud account.
|
|
10532
|
+
*
|
|
10533
|
+
* @param request DescribeSubaccountK8sClusterUserConfigRequest
|
|
10534
|
+
* @param headers map
|
|
10535
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
10536
|
+
* @return DescribeSubaccountK8sClusterUserConfigResponse
|
|
10537
|
+
*/
|
|
10538
|
+
async describeSubaccountK8sClusterUserConfigWithOptions(ClusterId, Uid, request, headers, runtime) {
|
|
10539
|
+
tea_util_1.default.validateModel(request);
|
|
10540
|
+
let query = {};
|
|
10541
|
+
if (!tea_util_1.default.isUnset(request.privateIpAddress)) {
|
|
10542
|
+
query["PrivateIpAddress"] = request.privateIpAddress;
|
|
10543
|
+
}
|
|
10544
|
+
if (!tea_util_1.default.isUnset(request.temporaryDurationMinutes)) {
|
|
10545
|
+
query["TemporaryDurationMinutes"] = request.temporaryDurationMinutes;
|
|
10546
|
+
}
|
|
10547
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
10548
|
+
headers: headers,
|
|
10549
|
+
query: openapi_util_1.default.query(query),
|
|
10550
|
+
});
|
|
10551
|
+
let params = new $OpenApi.Params({
|
|
10552
|
+
action: "DescribeSubaccountK8sClusterUserConfig",
|
|
10553
|
+
version: "2015-12-15",
|
|
10554
|
+
protocol: "HTTPS",
|
|
10555
|
+
pathname: `/k8s/${openapi_util_1.default.getEncodeParam(ClusterId)}/users/${openapi_util_1.default.getEncodeParam(Uid)}/user_config`,
|
|
10556
|
+
method: "GET",
|
|
10557
|
+
authType: "AK",
|
|
10558
|
+
style: "ROA",
|
|
10559
|
+
reqBodyType: "json",
|
|
10560
|
+
bodyType: "json",
|
|
10561
|
+
});
|
|
10562
|
+
return $tea.cast(await this.callApi(params, req, runtime), new DescribeSubaccountK8sClusterUserConfigResponse({}));
|
|
10563
|
+
}
|
|
10564
|
+
/**
|
|
10565
|
+
* > You can call this operation only with an Alibaba Cloud account.
|
|
10566
|
+
*
|
|
10567
|
+
* @param request DescribeSubaccountK8sClusterUserConfigRequest
|
|
10568
|
+
* @return DescribeSubaccountK8sClusterUserConfigResponse
|
|
10569
|
+
*/
|
|
10570
|
+
async describeSubaccountK8sClusterUserConfig(ClusterId, Uid, request) {
|
|
10571
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
10572
|
+
let headers = {};
|
|
10573
|
+
return await this.describeSubaccountK8sClusterUserConfigWithOptions(ClusterId, Uid, request, headers, runtime);
|
|
9550
10574
|
}
|
|
9551
10575
|
async describeTaskInfoWithOptions(taskId, headers, runtime) {
|
|
9552
10576
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -9565,10 +10589,10 @@ class Client extends openapi_client_1.default {
|
|
|
9565
10589
|
});
|
|
9566
10590
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeTaskInfoResponse({}));
|
|
9567
10591
|
}
|
|
9568
|
-
async
|
|
10592
|
+
async describeTaskInfo(taskId) {
|
|
9569
10593
|
let runtime = new $Util.RuntimeOptions({});
|
|
9570
10594
|
let headers = {};
|
|
9571
|
-
return await this.
|
|
10595
|
+
return await this.describeTaskInfoWithOptions(taskId, headers, runtime);
|
|
9572
10596
|
}
|
|
9573
10597
|
async describeTemplateAttributeWithOptions(TemplateId, request, headers, runtime) {
|
|
9574
10598
|
tea_util_1.default.validateModel(request);
|
|
@@ -9593,10 +10617,10 @@ class Client extends openapi_client_1.default {
|
|
|
9593
10617
|
});
|
|
9594
10618
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeTemplateAttributeResponse({}));
|
|
9595
10619
|
}
|
|
9596
|
-
async
|
|
10620
|
+
async describeTemplateAttribute(TemplateId, request) {
|
|
9597
10621
|
let runtime = new $Util.RuntimeOptions({});
|
|
9598
10622
|
let headers = {};
|
|
9599
|
-
return await this.
|
|
10623
|
+
return await this.describeTemplateAttributeWithOptions(TemplateId, request, headers, runtime);
|
|
9600
10624
|
}
|
|
9601
10625
|
async describeTemplatesWithOptions(request, headers, runtime) {
|
|
9602
10626
|
tea_util_1.default.validateModel(request);
|
|
@@ -9627,10 +10651,10 @@ class Client extends openapi_client_1.default {
|
|
|
9627
10651
|
});
|
|
9628
10652
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeTemplatesResponse({}));
|
|
9629
10653
|
}
|
|
9630
|
-
async
|
|
10654
|
+
async describeTemplates(request) {
|
|
9631
10655
|
let runtime = new $Util.RuntimeOptions({});
|
|
9632
10656
|
let headers = {};
|
|
9633
|
-
return await this.
|
|
10657
|
+
return await this.describeTemplatesWithOptions(request, headers, runtime);
|
|
9634
10658
|
}
|
|
9635
10659
|
async describeTriggerWithOptions(clusterId, request, headers, runtime) {
|
|
9636
10660
|
tea_util_1.default.validateModel(request);
|
|
@@ -9655,7 +10679,7 @@ class Client extends openapi_client_1.default {
|
|
|
9655
10679
|
action: "DescribeTrigger",
|
|
9656
10680
|
version: "2015-12-15",
|
|
9657
10681
|
protocol: "HTTPS",
|
|
9658
|
-
pathname: `/clusters
|
|
10682
|
+
pathname: `/clusters/${openapi_util_1.default.getEncodeParam(clusterId)}/triggers`,
|
|
9659
10683
|
method: "GET",
|
|
9660
10684
|
authType: "AK",
|
|
9661
10685
|
style: "ROA",
|
|
@@ -9664,10 +10688,32 @@ class Client extends openapi_client_1.default {
|
|
|
9664
10688
|
});
|
|
9665
10689
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeTriggerResponse({}));
|
|
9666
10690
|
}
|
|
9667
|
-
async
|
|
10691
|
+
async describeTrigger(clusterId, request) {
|
|
9668
10692
|
let runtime = new $Util.RuntimeOptions({});
|
|
9669
10693
|
let headers = {};
|
|
9670
|
-
return await this.
|
|
10694
|
+
return await this.describeTriggerWithOptions(clusterId, request, headers, runtime);
|
|
10695
|
+
}
|
|
10696
|
+
async describeUserClusterNamespacesWithOptions(ClusterId, headers, runtime) {
|
|
10697
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
10698
|
+
headers: headers,
|
|
10699
|
+
});
|
|
10700
|
+
let params = new $OpenApi.Params({
|
|
10701
|
+
action: "DescribeUserClusterNamespaces",
|
|
10702
|
+
version: "2015-12-15",
|
|
10703
|
+
protocol: "HTTPS",
|
|
10704
|
+
pathname: `/api/v2/k8s/${openapi_util_1.default.getEncodeParam(ClusterId)}/namespaces`,
|
|
10705
|
+
method: "GET",
|
|
10706
|
+
authType: "AK",
|
|
10707
|
+
style: "ROA",
|
|
10708
|
+
reqBodyType: "json",
|
|
10709
|
+
bodyType: "array",
|
|
10710
|
+
});
|
|
10711
|
+
return $tea.cast(await this.callApi(params, req, runtime), new DescribeUserClusterNamespacesResponse({}));
|
|
10712
|
+
}
|
|
10713
|
+
async describeUserClusterNamespaces(ClusterId) {
|
|
10714
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
10715
|
+
let headers = {};
|
|
10716
|
+
return await this.describeUserClusterNamespacesWithOptions(ClusterId, headers, runtime);
|
|
9671
10717
|
}
|
|
9672
10718
|
async describeUserPermissionWithOptions(uid, headers, runtime) {
|
|
9673
10719
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -9686,10 +10732,10 @@ class Client extends openapi_client_1.default {
|
|
|
9686
10732
|
});
|
|
9687
10733
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeUserPermissionResponse({}));
|
|
9688
10734
|
}
|
|
9689
|
-
async
|
|
10735
|
+
async describeUserPermission(uid) {
|
|
9690
10736
|
let runtime = new $Util.RuntimeOptions({});
|
|
9691
10737
|
let headers = {};
|
|
9692
|
-
return await this.
|
|
10738
|
+
return await this.describeUserPermissionWithOptions(uid, headers, runtime);
|
|
9693
10739
|
}
|
|
9694
10740
|
async describeUserQuotaWithOptions(headers, runtime) {
|
|
9695
10741
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -9708,10 +10754,10 @@ class Client extends openapi_client_1.default {
|
|
|
9708
10754
|
});
|
|
9709
10755
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeUserQuotaResponse({}));
|
|
9710
10756
|
}
|
|
9711
|
-
async
|
|
10757
|
+
async describeUserQuota() {
|
|
9712
10758
|
let runtime = new $Util.RuntimeOptions({});
|
|
9713
10759
|
let headers = {};
|
|
9714
|
-
return await this.
|
|
10760
|
+
return await this.describeUserQuotaWithOptions(headers, runtime);
|
|
9715
10761
|
}
|
|
9716
10762
|
async describeWorkflowsWithOptions(headers, runtime) {
|
|
9717
10763
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -9730,10 +10776,10 @@ class Client extends openapi_client_1.default {
|
|
|
9730
10776
|
});
|
|
9731
10777
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeWorkflowsResponse({}));
|
|
9732
10778
|
}
|
|
9733
|
-
async
|
|
10779
|
+
async describeWorkflows() {
|
|
9734
10780
|
let runtime = new $Util.RuntimeOptions({});
|
|
9735
10781
|
let headers = {};
|
|
9736
|
-
return await this.
|
|
10782
|
+
return await this.describeWorkflowsWithOptions(headers, runtime);
|
|
9737
10783
|
}
|
|
9738
10784
|
async edgeClusterAddEdgeMachineWithOptions(clusterid, edgeMachineid, request, headers, runtime) {
|
|
9739
10785
|
tea_util_1.default.validateModel(request);
|
|
@@ -9764,10 +10810,10 @@ class Client extends openapi_client_1.default {
|
|
|
9764
10810
|
});
|
|
9765
10811
|
return $tea.cast(await this.callApi(params, req, runtime), new EdgeClusterAddEdgeMachineResponse({}));
|
|
9766
10812
|
}
|
|
9767
|
-
async
|
|
10813
|
+
async edgeClusterAddEdgeMachine(clusterid, edgeMachineid, request) {
|
|
9768
10814
|
let runtime = new $Util.RuntimeOptions({});
|
|
9769
10815
|
let headers = {};
|
|
9770
|
-
return await this.
|
|
10816
|
+
return await this.edgeClusterAddEdgeMachineWithOptions(clusterid, edgeMachineid, request, headers, runtime);
|
|
9771
10817
|
}
|
|
9772
10818
|
async fixNodePoolVulsWithOptions(clusterId, nodepoolId, request, headers, runtime) {
|
|
9773
10819
|
tea_util_1.default.validateModel(request);
|
|
@@ -9775,11 +10821,11 @@ class Client extends openapi_client_1.default {
|
|
|
9775
10821
|
if (!tea_util_1.default.isUnset(request.nodes)) {
|
|
9776
10822
|
body["nodes"] = request.nodes;
|
|
9777
10823
|
}
|
|
9778
|
-
if (!tea_util_1.default.isUnset(
|
|
10824
|
+
if (!tea_util_1.default.isUnset(request.rolloutPolicy)) {
|
|
9779
10825
|
body["rollout_policy"] = request.rolloutPolicy;
|
|
9780
10826
|
}
|
|
9781
|
-
if (!tea_util_1.default.isUnset(request.
|
|
9782
|
-
body["
|
|
10827
|
+
if (!tea_util_1.default.isUnset(request.vuls)) {
|
|
10828
|
+
body["vuls"] = request.vuls;
|
|
9783
10829
|
}
|
|
9784
10830
|
let req = new $OpenApi.OpenApiRequest({
|
|
9785
10831
|
headers: headers,
|
|
@@ -9798,10 +10844,10 @@ class Client extends openapi_client_1.default {
|
|
|
9798
10844
|
});
|
|
9799
10845
|
return $tea.cast(await this.callApi(params, req, runtime), new FixNodePoolVulsResponse({}));
|
|
9800
10846
|
}
|
|
9801
|
-
async
|
|
10847
|
+
async fixNodePoolVuls(clusterId, nodepoolId, request) {
|
|
9802
10848
|
let runtime = new $Util.RuntimeOptions({});
|
|
9803
10849
|
let headers = {};
|
|
9804
|
-
return await this.
|
|
10850
|
+
return await this.fixNodePoolVulsWithOptions(clusterId, nodepoolId, request, headers, runtime);
|
|
9805
10851
|
}
|
|
9806
10852
|
async getKubernetesTriggerWithOptions(ClusterId, request, headers, runtime) {
|
|
9807
10853
|
tea_util_1.default.validateModel(request);
|
|
@@ -9835,10 +10881,10 @@ class Client extends openapi_client_1.default {
|
|
|
9835
10881
|
});
|
|
9836
10882
|
return $tea.cast(await this.callApi(params, req, runtime), new GetKubernetesTriggerResponse({}));
|
|
9837
10883
|
}
|
|
9838
|
-
async
|
|
10884
|
+
async getKubernetesTrigger(ClusterId, request) {
|
|
9839
10885
|
let runtime = new $Util.RuntimeOptions({});
|
|
9840
10886
|
let headers = {};
|
|
9841
|
-
return await this.
|
|
10887
|
+
return await this.getKubernetesTriggerWithOptions(ClusterId, request, headers, runtime);
|
|
9842
10888
|
}
|
|
9843
10889
|
async getUpgradeStatusWithOptions(ClusterId, headers, runtime) {
|
|
9844
10890
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -9857,11 +10903,23 @@ class Client extends openapi_client_1.default {
|
|
|
9857
10903
|
});
|
|
9858
10904
|
return $tea.cast(await this.callApi(params, req, runtime), new GetUpgradeStatusResponse({}));
|
|
9859
10905
|
}
|
|
9860
|
-
async
|
|
10906
|
+
async getUpgradeStatus(ClusterId) {
|
|
9861
10907
|
let runtime = new $Util.RuntimeOptions({});
|
|
9862
10908
|
let headers = {};
|
|
9863
|
-
return await this.
|
|
10909
|
+
return await this.getUpgradeStatusWithOptions(ClusterId, headers, runtime);
|
|
9864
10910
|
}
|
|
10911
|
+
/**
|
|
10912
|
+
* **Precautions**:
|
|
10913
|
+
* * Make sure that you have granted the specified RAM user at least read permissions on the specified cluster by attaching RAM policies. Otherwise, the `ErrorRamPolicyConfig` error will be returned.
|
|
10914
|
+
* For more information about how to authorize a RAM user by attaching RAM policies, see [Create a custom RAM policy](~~86485~~).
|
|
10915
|
+
* * If you call this operation as a RAM user, make sure that this RAM user has the permissions to grant other RAM users the permissions to manage ACK clusters. Otherwise, the `StatusForbidden` or `ForbiddenGrantPermissions` errors will be returned. For more information, see [Use a RAM user to grant RBAC permissions to other RAM users](~~119035~~).
|
|
10916
|
+
* * This operation overwrites the permissions that have been granted to the specified RAM user. When you call this operation, make sure that the required permissions are included.
|
|
10917
|
+
*
|
|
10918
|
+
* @param request GrantPermissionsRequest
|
|
10919
|
+
* @param headers map
|
|
10920
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
10921
|
+
* @return GrantPermissionsResponse
|
|
10922
|
+
*/
|
|
9865
10923
|
async grantPermissionsWithOptions(uid, request, headers, runtime) {
|
|
9866
10924
|
tea_util_1.default.validateModel(request);
|
|
9867
10925
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -9881,10 +10939,20 @@ class Client extends openapi_client_1.default {
|
|
|
9881
10939
|
});
|
|
9882
10940
|
return $tea.cast(await this.callApi(params, req, runtime), new GrantPermissionsResponse({}));
|
|
9883
10941
|
}
|
|
9884
|
-
|
|
10942
|
+
/**
|
|
10943
|
+
* **Precautions**:
|
|
10944
|
+
* * Make sure that you have granted the specified RAM user at least read permissions on the specified cluster by attaching RAM policies. Otherwise, the `ErrorRamPolicyConfig` error will be returned.
|
|
10945
|
+
* For more information about how to authorize a RAM user by attaching RAM policies, see [Create a custom RAM policy](~~86485~~).
|
|
10946
|
+
* * If you call this operation as a RAM user, make sure that this RAM user has the permissions to grant other RAM users the permissions to manage ACK clusters. Otherwise, the `StatusForbidden` or `ForbiddenGrantPermissions` errors will be returned. For more information, see [Use a RAM user to grant RBAC permissions to other RAM users](~~119035~~).
|
|
10947
|
+
* * This operation overwrites the permissions that have been granted to the specified RAM user. When you call this operation, make sure that the required permissions are included.
|
|
10948
|
+
*
|
|
10949
|
+
* @param request GrantPermissionsRequest
|
|
10950
|
+
* @return GrantPermissionsResponse
|
|
10951
|
+
*/
|
|
10952
|
+
async grantPermissions(uid, request) {
|
|
9885
10953
|
let runtime = new $Util.RuntimeOptions({});
|
|
9886
10954
|
let headers = {};
|
|
9887
|
-
return await this.
|
|
10955
|
+
return await this.grantPermissionsWithOptions(uid, request, headers, runtime);
|
|
9888
10956
|
}
|
|
9889
10957
|
async installClusterAddonsWithOptions(ClusterId, request, headers, runtime) {
|
|
9890
10958
|
tea_util_1.default.validateModel(request);
|
|
@@ -9905,10 +10973,10 @@ class Client extends openapi_client_1.default {
|
|
|
9905
10973
|
});
|
|
9906
10974
|
return $tea.cast(await this.callApi(params, req, runtime), new InstallClusterAddonsResponse({}));
|
|
9907
10975
|
}
|
|
9908
|
-
async
|
|
10976
|
+
async installClusterAddons(ClusterId, request) {
|
|
9909
10977
|
let runtime = new $Util.RuntimeOptions({});
|
|
9910
10978
|
let headers = {};
|
|
9911
|
-
return await this.
|
|
10979
|
+
return await this.installClusterAddonsWithOptions(ClusterId, request, headers, runtime);
|
|
9912
10980
|
}
|
|
9913
10981
|
async listTagResourcesWithOptions(tmpReq, headers, runtime) {
|
|
9914
10982
|
tea_util_1.default.validateModel(tmpReq);
|
|
@@ -9953,10 +11021,10 @@ class Client extends openapi_client_1.default {
|
|
|
9953
11021
|
});
|
|
9954
11022
|
return $tea.cast(await this.callApi(params, req, runtime), new ListTagResourcesResponse({}));
|
|
9955
11023
|
}
|
|
9956
|
-
async
|
|
11024
|
+
async listTagResources(request) {
|
|
9957
11025
|
let runtime = new $Util.RuntimeOptions({});
|
|
9958
11026
|
let headers = {};
|
|
9959
|
-
return await this.
|
|
11027
|
+
return await this.listTagResourcesWithOptions(request, headers, runtime);
|
|
9960
11028
|
}
|
|
9961
11029
|
async migrateClusterWithOptions(clusterId, request, headers, runtime) {
|
|
9962
11030
|
tea_util_1.default.validateModel(request);
|
|
@@ -9984,10 +11052,10 @@ class Client extends openapi_client_1.default {
|
|
|
9984
11052
|
});
|
|
9985
11053
|
return $tea.cast(await this.callApi(params, req, runtime), new MigrateClusterResponse({}));
|
|
9986
11054
|
}
|
|
9987
|
-
async
|
|
11055
|
+
async migrateCluster(clusterId, request) {
|
|
9988
11056
|
let runtime = new $Util.RuntimeOptions({});
|
|
9989
11057
|
let headers = {};
|
|
9990
|
-
return await this.
|
|
11058
|
+
return await this.migrateClusterWithOptions(clusterId, request, headers, runtime);
|
|
9991
11059
|
}
|
|
9992
11060
|
async modifyClusterWithOptions(ClusterId, request, headers, runtime) {
|
|
9993
11061
|
tea_util_1.default.validateModel(request);
|
|
@@ -10013,7 +11081,7 @@ class Client extends openapi_client_1.default {
|
|
|
10013
11081
|
if (!tea_util_1.default.isUnset(request.instanceDeletionProtection)) {
|
|
10014
11082
|
body["instance_deletion_protection"] = request.instanceDeletionProtection;
|
|
10015
11083
|
}
|
|
10016
|
-
if (!tea_util_1.default.isUnset(
|
|
11084
|
+
if (!tea_util_1.default.isUnset(request.maintenanceWindow)) {
|
|
10017
11085
|
body["maintenance_window"] = request.maintenanceWindow;
|
|
10018
11086
|
}
|
|
10019
11087
|
if (!tea_util_1.default.isUnset(request.resourceGroupId)) {
|
|
@@ -10036,11 +11104,22 @@ class Client extends openapi_client_1.default {
|
|
|
10036
11104
|
});
|
|
10037
11105
|
return $tea.cast(await this.callApi(params, req, runtime), new ModifyClusterResponse({}));
|
|
10038
11106
|
}
|
|
10039
|
-
async
|
|
11107
|
+
async modifyCluster(ClusterId, request) {
|
|
10040
11108
|
let runtime = new $Util.RuntimeOptions({});
|
|
10041
11109
|
let headers = {};
|
|
10042
|
-
return await this.
|
|
11110
|
+
return await this.modifyClusterWithOptions(ClusterId, request, headers, runtime);
|
|
10043
11111
|
}
|
|
11112
|
+
/**
|
|
11113
|
+
* You can use this API operation to modify the components in a Container Service for Kubernetes (ACK) cluster or the control plane components in an ACK Pro cluster.
|
|
11114
|
+
* * To query the customizable parameters of a component, call the `DescribeClusterAddonMetadata` API operation. For more information, see [Query the metadata of a specified component version](https://www.alibabacloud.com/help/zh/container-service-for-kubernetes/latest/query).
|
|
11115
|
+
* * For more information about the customizable parameters of control plane components in ACK Pro clusters, see [Customize the parameters of control plane components in ACK Pro clusters](https://www.alibabacloud.com/help/zh/container-service-for-kubernetes/latest/customize-control-plane-parameters-for-a-professional-kubernetes-cluster).
|
|
11116
|
+
* After you call this operation, the component may be redeployed and restarted. We recommend that you evaluate the impact before you call this operation.
|
|
11117
|
+
*
|
|
11118
|
+
* @param request ModifyClusterAddonRequest
|
|
11119
|
+
* @param headers map
|
|
11120
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
11121
|
+
* @return ModifyClusterAddonResponse
|
|
11122
|
+
*/
|
|
10044
11123
|
async modifyClusterAddonWithOptions(clusterId, componentId, request, headers, runtime) {
|
|
10045
11124
|
tea_util_1.default.validateModel(request);
|
|
10046
11125
|
let body = {};
|
|
@@ -10064,10 +11143,19 @@ class Client extends openapi_client_1.default {
|
|
|
10064
11143
|
});
|
|
10065
11144
|
return $tea.cast(await this.callApi(params, req, runtime), new ModifyClusterAddonResponse({}));
|
|
10066
11145
|
}
|
|
10067
|
-
|
|
11146
|
+
/**
|
|
11147
|
+
* You can use this API operation to modify the components in a Container Service for Kubernetes (ACK) cluster or the control plane components in an ACK Pro cluster.
|
|
11148
|
+
* * To query the customizable parameters of a component, call the `DescribeClusterAddonMetadata` API operation. For more information, see [Query the metadata of a specified component version](https://www.alibabacloud.com/help/zh/container-service-for-kubernetes/latest/query).
|
|
11149
|
+
* * For more information about the customizable parameters of control plane components in ACK Pro clusters, see [Customize the parameters of control plane components in ACK Pro clusters](https://www.alibabacloud.com/help/zh/container-service-for-kubernetes/latest/customize-control-plane-parameters-for-a-professional-kubernetes-cluster).
|
|
11150
|
+
* After you call this operation, the component may be redeployed and restarted. We recommend that you evaluate the impact before you call this operation.
|
|
11151
|
+
*
|
|
11152
|
+
* @param request ModifyClusterAddonRequest
|
|
11153
|
+
* @return ModifyClusterAddonResponse
|
|
11154
|
+
*/
|
|
11155
|
+
async modifyClusterAddon(clusterId, componentId, request) {
|
|
10068
11156
|
let runtime = new $Util.RuntimeOptions({});
|
|
10069
11157
|
let headers = {};
|
|
10070
|
-
return await this.
|
|
11158
|
+
return await this.modifyClusterAddonWithOptions(clusterId, componentId, request, headers, runtime);
|
|
10071
11159
|
}
|
|
10072
11160
|
async modifyClusterConfigurationWithOptions(ClusterId, request, headers, runtime) {
|
|
10073
11161
|
tea_util_1.default.validateModel(request);
|
|
@@ -10092,30 +11180,30 @@ class Client extends openapi_client_1.default {
|
|
|
10092
11180
|
});
|
|
10093
11181
|
return $tea.cast(await this.callApi(params, req, runtime), new ModifyClusterConfigurationResponse({}));
|
|
10094
11182
|
}
|
|
10095
|
-
async
|
|
11183
|
+
async modifyClusterConfiguration(ClusterId, request) {
|
|
10096
11184
|
let runtime = new $Util.RuntimeOptions({});
|
|
10097
11185
|
let headers = {};
|
|
10098
|
-
return await this.
|
|
11186
|
+
return await this.modifyClusterConfigurationWithOptions(ClusterId, request, headers, runtime);
|
|
10099
11187
|
}
|
|
10100
11188
|
async modifyClusterNodePoolWithOptions(ClusterId, NodepoolId, request, headers, runtime) {
|
|
10101
11189
|
tea_util_1.default.validateModel(request);
|
|
10102
11190
|
let body = {};
|
|
10103
|
-
if (!tea_util_1.default.isUnset(
|
|
11191
|
+
if (!tea_util_1.default.isUnset(request.autoScaling)) {
|
|
10104
11192
|
body["auto_scaling"] = request.autoScaling;
|
|
10105
11193
|
}
|
|
10106
|
-
if (!tea_util_1.default.isUnset(
|
|
11194
|
+
if (!tea_util_1.default.isUnset(request.kubernetesConfig)) {
|
|
10107
11195
|
body["kubernetes_config"] = request.kubernetesConfig;
|
|
10108
11196
|
}
|
|
10109
|
-
if (!tea_util_1.default.isUnset(
|
|
11197
|
+
if (!tea_util_1.default.isUnset(request.management)) {
|
|
10110
11198
|
body["management"] = request.management;
|
|
10111
11199
|
}
|
|
10112
|
-
if (!tea_util_1.default.isUnset(
|
|
11200
|
+
if (!tea_util_1.default.isUnset(request.nodepoolInfo)) {
|
|
10113
11201
|
body["nodepool_info"] = request.nodepoolInfo;
|
|
10114
11202
|
}
|
|
10115
|
-
if (!tea_util_1.default.isUnset(
|
|
11203
|
+
if (!tea_util_1.default.isUnset(request.scalingGroup)) {
|
|
10116
11204
|
body["scaling_group"] = request.scalingGroup;
|
|
10117
11205
|
}
|
|
10118
|
-
if (!tea_util_1.default.isUnset(
|
|
11206
|
+
if (!tea_util_1.default.isUnset(request.teeConfig)) {
|
|
10119
11207
|
body["tee_config"] = request.teeConfig;
|
|
10120
11208
|
}
|
|
10121
11209
|
if (!tea_util_1.default.isUnset(request.updateNodes)) {
|
|
@@ -10138,10 +11226,10 @@ class Client extends openapi_client_1.default {
|
|
|
10138
11226
|
});
|
|
10139
11227
|
return $tea.cast(await this.callApi(params, req, runtime), new ModifyClusterNodePoolResponse({}));
|
|
10140
11228
|
}
|
|
10141
|
-
async
|
|
11229
|
+
async modifyClusterNodePool(ClusterId, NodepoolId, request) {
|
|
10142
11230
|
let runtime = new $Util.RuntimeOptions({});
|
|
10143
11231
|
let headers = {};
|
|
10144
|
-
return await this.
|
|
11232
|
+
return await this.modifyClusterNodePoolWithOptions(ClusterId, NodepoolId, request, headers, runtime);
|
|
10145
11233
|
}
|
|
10146
11234
|
async modifyClusterTagsWithOptions(ClusterId, request, headers, runtime) {
|
|
10147
11235
|
tea_util_1.default.validateModel(request);
|
|
@@ -10162,18 +11250,18 @@ class Client extends openapi_client_1.default {
|
|
|
10162
11250
|
});
|
|
10163
11251
|
return $tea.cast(await this.callApi(params, req, runtime), new ModifyClusterTagsResponse({}));
|
|
10164
11252
|
}
|
|
10165
|
-
async
|
|
11253
|
+
async modifyClusterTags(ClusterId, request) {
|
|
10166
11254
|
let runtime = new $Util.RuntimeOptions({});
|
|
10167
11255
|
let headers = {};
|
|
10168
|
-
return await this.
|
|
11256
|
+
return await this.modifyClusterTagsWithOptions(ClusterId, request, headers, runtime);
|
|
10169
11257
|
}
|
|
10170
11258
|
async modifyNodePoolNodeConfigWithOptions(ClusterId, NodepoolId, request, headers, runtime) {
|
|
10171
11259
|
tea_util_1.default.validateModel(request);
|
|
10172
11260
|
let body = {};
|
|
10173
|
-
if (!tea_util_1.default.isUnset(
|
|
11261
|
+
if (!tea_util_1.default.isUnset(request.kubeletConfig)) {
|
|
10174
11262
|
body["kubelet_config"] = request.kubeletConfig;
|
|
10175
11263
|
}
|
|
10176
|
-
if (!tea_util_1.default.isUnset(
|
|
11264
|
+
if (!tea_util_1.default.isUnset(request.rollingPolicy)) {
|
|
10177
11265
|
body["rolling_policy"] = request.rollingPolicy;
|
|
10178
11266
|
}
|
|
10179
11267
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -10193,10 +11281,10 @@ class Client extends openapi_client_1.default {
|
|
|
10193
11281
|
});
|
|
10194
11282
|
return $tea.cast(await this.callApi(params, req, runtime), new ModifyNodePoolNodeConfigResponse({}));
|
|
10195
11283
|
}
|
|
10196
|
-
async
|
|
11284
|
+
async modifyNodePoolNodeConfig(ClusterId, NodepoolId, request) {
|
|
10197
11285
|
let runtime = new $Util.RuntimeOptions({});
|
|
10198
11286
|
let headers = {};
|
|
10199
|
-
return await this.
|
|
11287
|
+
return await this.modifyNodePoolNodeConfigWithOptions(ClusterId, NodepoolId, request, headers, runtime);
|
|
10200
11288
|
}
|
|
10201
11289
|
async modifyPolicyInstanceWithOptions(clusterId, policyName, request, headers, runtime) {
|
|
10202
11290
|
tea_util_1.default.validateModel(request);
|
|
@@ -10230,11 +11318,19 @@ class Client extends openapi_client_1.default {
|
|
|
10230
11318
|
});
|
|
10231
11319
|
return $tea.cast(await this.callApi(params, req, runtime), new ModifyPolicyInstanceResponse({}));
|
|
10232
11320
|
}
|
|
10233
|
-
async
|
|
11321
|
+
async modifyPolicyInstance(clusterId, policyName, request) {
|
|
10234
11322
|
let runtime = new $Util.RuntimeOptions({});
|
|
10235
11323
|
let headers = {};
|
|
10236
|
-
return await this.
|
|
11324
|
+
return await this.modifyPolicyInstanceWithOptions(clusterId, policyName, request, headers, runtime);
|
|
10237
11325
|
}
|
|
11326
|
+
/**
|
|
11327
|
+
* You can activate ACK with Alibaba Cloud accounts or RAM users that have the authority of AdministratorAccess.
|
|
11328
|
+
*
|
|
11329
|
+
* @param request OpenAckServiceRequest
|
|
11330
|
+
* @param headers map
|
|
11331
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
11332
|
+
* @return OpenAckServiceResponse
|
|
11333
|
+
*/
|
|
10238
11334
|
async openAckServiceWithOptions(request, headers, runtime) {
|
|
10239
11335
|
tea_util_1.default.validateModel(request);
|
|
10240
11336
|
let query = {};
|
|
@@ -10258,10 +11354,16 @@ class Client extends openapi_client_1.default {
|
|
|
10258
11354
|
});
|
|
10259
11355
|
return $tea.cast(await this.callApi(params, req, runtime), new OpenAckServiceResponse({}));
|
|
10260
11356
|
}
|
|
10261
|
-
|
|
11357
|
+
/**
|
|
11358
|
+
* You can activate ACK with Alibaba Cloud accounts or RAM users that have the authority of AdministratorAccess.
|
|
11359
|
+
*
|
|
11360
|
+
* @param request OpenAckServiceRequest
|
|
11361
|
+
* @return OpenAckServiceResponse
|
|
11362
|
+
*/
|
|
11363
|
+
async openAckService(request) {
|
|
10262
11364
|
let runtime = new $Util.RuntimeOptions({});
|
|
10263
11365
|
let headers = {};
|
|
10264
|
-
return await this.
|
|
11366
|
+
return await this.openAckServiceWithOptions(request, headers, runtime);
|
|
10265
11367
|
}
|
|
10266
11368
|
async pauseClusterUpgradeWithOptions(ClusterId, headers, runtime) {
|
|
10267
11369
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -10280,10 +11382,10 @@ class Client extends openapi_client_1.default {
|
|
|
10280
11382
|
});
|
|
10281
11383
|
return $tea.cast(await this.callApi(params, req, runtime), new PauseClusterUpgradeResponse({}));
|
|
10282
11384
|
}
|
|
10283
|
-
async
|
|
11385
|
+
async pauseClusterUpgrade(ClusterId) {
|
|
10284
11386
|
let runtime = new $Util.RuntimeOptions({});
|
|
10285
11387
|
let headers = {};
|
|
10286
|
-
return await this.
|
|
11388
|
+
return await this.pauseClusterUpgradeWithOptions(ClusterId, headers, runtime);
|
|
10287
11389
|
}
|
|
10288
11390
|
async pauseComponentUpgradeWithOptions(clusterid, componentid, headers, runtime) {
|
|
10289
11391
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -10302,10 +11404,10 @@ class Client extends openapi_client_1.default {
|
|
|
10302
11404
|
});
|
|
10303
11405
|
return $tea.cast(await this.callApi(params, req, runtime), new PauseComponentUpgradeResponse({}));
|
|
10304
11406
|
}
|
|
10305
|
-
async
|
|
11407
|
+
async pauseComponentUpgrade(clusterid, componentid) {
|
|
10306
11408
|
let runtime = new $Util.RuntimeOptions({});
|
|
10307
11409
|
let headers = {};
|
|
10308
|
-
return await this.
|
|
11410
|
+
return await this.pauseComponentUpgradeWithOptions(clusterid, componentid, headers, runtime);
|
|
10309
11411
|
}
|
|
10310
11412
|
async pauseTaskWithOptions(taskId, headers, runtime) {
|
|
10311
11413
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -10324,11 +11426,20 @@ class Client extends openapi_client_1.default {
|
|
|
10324
11426
|
});
|
|
10325
11427
|
return $tea.cast(await this.callApi(params, req, runtime), new PauseTaskResponse({}));
|
|
10326
11428
|
}
|
|
10327
|
-
async
|
|
11429
|
+
async pauseTask(taskId) {
|
|
10328
11430
|
let runtime = new $Util.RuntimeOptions({});
|
|
10329
11431
|
let headers = {};
|
|
10330
|
-
return await this.
|
|
11432
|
+
return await this.pauseTaskWithOptions(taskId, headers, runtime);
|
|
10331
11433
|
}
|
|
11434
|
+
/**
|
|
11435
|
+
* @deprecated
|
|
11436
|
+
*
|
|
11437
|
+
* @param request RemoveClusterNodesRequest
|
|
11438
|
+
* @param headers map
|
|
11439
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
11440
|
+
* @return RemoveClusterNodesResponse
|
|
11441
|
+
*/
|
|
11442
|
+
// Deprecated
|
|
10332
11443
|
async removeClusterNodesWithOptions(ClusterId, request, headers, runtime) {
|
|
10333
11444
|
tea_util_1.default.validateModel(request);
|
|
10334
11445
|
let body = {};
|
|
@@ -10358,15 +11469,37 @@ class Client extends openapi_client_1.default {
|
|
|
10358
11469
|
});
|
|
10359
11470
|
return $tea.cast(await this.callApi(params, req, runtime), new RemoveClusterNodesResponse({}));
|
|
10360
11471
|
}
|
|
10361
|
-
|
|
11472
|
+
/**
|
|
11473
|
+
* @deprecated
|
|
11474
|
+
*
|
|
11475
|
+
* @param request RemoveClusterNodesRequest
|
|
11476
|
+
* @return RemoveClusterNodesResponse
|
|
11477
|
+
*/
|
|
11478
|
+
// Deprecated
|
|
11479
|
+
async removeClusterNodes(ClusterId, request) {
|
|
10362
11480
|
let runtime = new $Util.RuntimeOptions({});
|
|
10363
11481
|
let headers = {};
|
|
10364
|
-
return await this.
|
|
11482
|
+
return await this.removeClusterNodesWithOptions(ClusterId, request, headers, runtime);
|
|
10365
11483
|
}
|
|
11484
|
+
/**
|
|
11485
|
+
* >
|
|
11486
|
+
* * When you remove a node, the pods that run on the node are migrated to other nodes. This may cause service interruptions. We recommend that you remove nodes during off-peak hours.
|
|
11487
|
+
* * Unknown errors may occur when you remove nodes. Before you remove nodes, back up the data on the nodes.
|
|
11488
|
+
* * Nodes remain in the Unschedulable state when they are being removed.
|
|
11489
|
+
* * You can remove only worker nodes. You cannot remove control planes.
|
|
11490
|
+
*
|
|
11491
|
+
* @param tmpReq RemoveNodePoolNodesRequest
|
|
11492
|
+
* @param headers map
|
|
11493
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
11494
|
+
* @return RemoveNodePoolNodesResponse
|
|
11495
|
+
*/
|
|
10366
11496
|
async removeNodePoolNodesWithOptions(ClusterId, NodepoolId, tmpReq, headers, runtime) {
|
|
10367
11497
|
tea_util_1.default.validateModel(tmpReq);
|
|
10368
11498
|
let request = new RemoveNodePoolNodesShrinkRequest({});
|
|
10369
11499
|
openapi_util_1.default.convert(tmpReq, request);
|
|
11500
|
+
if (!tea_util_1.default.isUnset(tmpReq.instanceIds)) {
|
|
11501
|
+
request.instanceIdsShrink = openapi_util_1.default.arrayToStringWithSpecifiedStyle(tmpReq.instanceIds, "instance_ids", "json");
|
|
11502
|
+
}
|
|
10370
11503
|
if (!tea_util_1.default.isUnset(tmpReq.nodes)) {
|
|
10371
11504
|
request.nodesShrink = openapi_util_1.default.arrayToStringWithSpecifiedStyle(tmpReq.nodes, "nodes", "json");
|
|
10372
11505
|
}
|
|
@@ -10374,6 +11507,9 @@ class Client extends openapi_client_1.default {
|
|
|
10374
11507
|
if (!tea_util_1.default.isUnset(request.drainNode)) {
|
|
10375
11508
|
query["drain_node"] = request.drainNode;
|
|
10376
11509
|
}
|
|
11510
|
+
if (!tea_util_1.default.isUnset(request.instanceIdsShrink)) {
|
|
11511
|
+
query["instance_ids"] = request.instanceIdsShrink;
|
|
11512
|
+
}
|
|
10377
11513
|
if (!tea_util_1.default.isUnset(request.nodesShrink)) {
|
|
10378
11514
|
query["nodes"] = request.nodesShrink;
|
|
10379
11515
|
}
|
|
@@ -10397,10 +11533,20 @@ class Client extends openapi_client_1.default {
|
|
|
10397
11533
|
});
|
|
10398
11534
|
return $tea.cast(await this.callApi(params, req, runtime), new RemoveNodePoolNodesResponse({}));
|
|
10399
11535
|
}
|
|
10400
|
-
|
|
11536
|
+
/**
|
|
11537
|
+
* >
|
|
11538
|
+
* * When you remove a node, the pods that run on the node are migrated to other nodes. This may cause service interruptions. We recommend that you remove nodes during off-peak hours.
|
|
11539
|
+
* * Unknown errors may occur when you remove nodes. Before you remove nodes, back up the data on the nodes.
|
|
11540
|
+
* * Nodes remain in the Unschedulable state when they are being removed.
|
|
11541
|
+
* * You can remove only worker nodes. You cannot remove control planes.
|
|
11542
|
+
*
|
|
11543
|
+
* @param request RemoveNodePoolNodesRequest
|
|
11544
|
+
* @return RemoveNodePoolNodesResponse
|
|
11545
|
+
*/
|
|
11546
|
+
async removeNodePoolNodes(ClusterId, NodepoolId, request) {
|
|
10401
11547
|
let runtime = new $Util.RuntimeOptions({});
|
|
10402
11548
|
let headers = {};
|
|
10403
|
-
return await this.
|
|
11549
|
+
return await this.removeNodePoolNodesWithOptions(ClusterId, NodepoolId, request, headers, runtime);
|
|
10404
11550
|
}
|
|
10405
11551
|
async removeWorkflowWithOptions(workflowName, headers, runtime) {
|
|
10406
11552
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -10419,10 +11565,10 @@ class Client extends openapi_client_1.default {
|
|
|
10419
11565
|
});
|
|
10420
11566
|
return $tea.cast(await this.callApi(params, req, runtime), new RemoveWorkflowResponse({}));
|
|
10421
11567
|
}
|
|
10422
|
-
async
|
|
11568
|
+
async removeWorkflow(workflowName) {
|
|
10423
11569
|
let runtime = new $Util.RuntimeOptions({});
|
|
10424
11570
|
let headers = {};
|
|
10425
|
-
return await this.
|
|
11571
|
+
return await this.removeWorkflowWithOptions(workflowName, headers, runtime);
|
|
10426
11572
|
}
|
|
10427
11573
|
async repairClusterNodePoolWithOptions(clusterId, nodepoolId, request, headers, runtime) {
|
|
10428
11574
|
tea_util_1.default.validateModel(request);
|
|
@@ -10447,10 +11593,10 @@ class Client extends openapi_client_1.default {
|
|
|
10447
11593
|
});
|
|
10448
11594
|
return $tea.cast(await this.callApi(params, req, runtime), new RepairClusterNodePoolResponse({}));
|
|
10449
11595
|
}
|
|
10450
|
-
async
|
|
11596
|
+
async repairClusterNodePool(clusterId, nodepoolId, request) {
|
|
10451
11597
|
let runtime = new $Util.RuntimeOptions({});
|
|
10452
11598
|
let headers = {};
|
|
10453
|
-
return await this.
|
|
11599
|
+
return await this.repairClusterNodePoolWithOptions(clusterId, nodepoolId, request, headers, runtime);
|
|
10454
11600
|
}
|
|
10455
11601
|
async resumeComponentUpgradeWithOptions(clusterid, componentid, headers, runtime) {
|
|
10456
11602
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -10469,10 +11615,10 @@ class Client extends openapi_client_1.default {
|
|
|
10469
11615
|
});
|
|
10470
11616
|
return $tea.cast(await this.callApi(params, req, runtime), new ResumeComponentUpgradeResponse({}));
|
|
10471
11617
|
}
|
|
10472
|
-
async
|
|
11618
|
+
async resumeComponentUpgrade(clusterid, componentid) {
|
|
10473
11619
|
let runtime = new $Util.RuntimeOptions({});
|
|
10474
11620
|
let headers = {};
|
|
10475
|
-
return await this.
|
|
11621
|
+
return await this.resumeComponentUpgradeWithOptions(clusterid, componentid, headers, runtime);
|
|
10476
11622
|
}
|
|
10477
11623
|
async resumeTaskWithOptions(taskId, headers, runtime) {
|
|
10478
11624
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -10491,10 +11637,10 @@ class Client extends openapi_client_1.default {
|
|
|
10491
11637
|
});
|
|
10492
11638
|
return $tea.cast(await this.callApi(params, req, runtime), new ResumeTaskResponse({}));
|
|
10493
11639
|
}
|
|
10494
|
-
async
|
|
11640
|
+
async resumeTask(taskId) {
|
|
10495
11641
|
let runtime = new $Util.RuntimeOptions({});
|
|
10496
11642
|
let headers = {};
|
|
10497
|
-
return await this.
|
|
11643
|
+
return await this.resumeTaskWithOptions(taskId, headers, runtime);
|
|
10498
11644
|
}
|
|
10499
11645
|
async resumeUpgradeClusterWithOptions(ClusterId, headers, runtime) {
|
|
10500
11646
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -10513,11 +11659,20 @@ class Client extends openapi_client_1.default {
|
|
|
10513
11659
|
});
|
|
10514
11660
|
return $tea.cast(await this.callApi(params, req, runtime), new ResumeUpgradeClusterResponse({}));
|
|
10515
11661
|
}
|
|
10516
|
-
async
|
|
11662
|
+
async resumeUpgradeCluster(ClusterId) {
|
|
10517
11663
|
let runtime = new $Util.RuntimeOptions({});
|
|
10518
11664
|
let headers = {};
|
|
10519
|
-
return await this.
|
|
11665
|
+
return await this.resumeUpgradeClusterWithOptions(ClusterId, headers, runtime);
|
|
10520
11666
|
}
|
|
11667
|
+
/**
|
|
11668
|
+
* @deprecated
|
|
11669
|
+
*
|
|
11670
|
+
* @param request ScaleClusterRequest
|
|
11671
|
+
* @param headers map
|
|
11672
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
11673
|
+
* @return ScaleClusterResponse
|
|
11674
|
+
*/
|
|
11675
|
+
// Deprecated
|
|
10521
11676
|
async scaleClusterWithOptions(ClusterId, request, headers, runtime) {
|
|
10522
11677
|
tea_util_1.default.validateModel(request);
|
|
10523
11678
|
let body = {};
|
|
@@ -10595,10 +11750,17 @@ class Client extends openapi_client_1.default {
|
|
|
10595
11750
|
});
|
|
10596
11751
|
return $tea.cast(await this.callApi(params, req, runtime), new ScaleClusterResponse({}));
|
|
10597
11752
|
}
|
|
10598
|
-
|
|
11753
|
+
/**
|
|
11754
|
+
* @deprecated
|
|
11755
|
+
*
|
|
11756
|
+
* @param request ScaleClusterRequest
|
|
11757
|
+
* @return ScaleClusterResponse
|
|
11758
|
+
*/
|
|
11759
|
+
// Deprecated
|
|
11760
|
+
async scaleCluster(ClusterId, request) {
|
|
10599
11761
|
let runtime = new $Util.RuntimeOptions({});
|
|
10600
11762
|
let headers = {};
|
|
10601
|
-
return await this.
|
|
11763
|
+
return await this.scaleClusterWithOptions(ClusterId, request, headers, runtime);
|
|
10602
11764
|
}
|
|
10603
11765
|
async scaleClusterNodePoolWithOptions(ClusterId, NodepoolId, request, headers, runtime) {
|
|
10604
11766
|
tea_util_1.default.validateModel(request);
|
|
@@ -10623,11 +11785,19 @@ class Client extends openapi_client_1.default {
|
|
|
10623
11785
|
});
|
|
10624
11786
|
return $tea.cast(await this.callApi(params, req, runtime), new ScaleClusterNodePoolResponse({}));
|
|
10625
11787
|
}
|
|
10626
|
-
async
|
|
11788
|
+
async scaleClusterNodePool(ClusterId, NodepoolId, request) {
|
|
10627
11789
|
let runtime = new $Util.RuntimeOptions({});
|
|
10628
11790
|
let headers = {};
|
|
10629
|
-
return await this.
|
|
11791
|
+
return await this.scaleClusterNodePoolWithOptions(ClusterId, NodepoolId, request, headers, runtime);
|
|
10630
11792
|
}
|
|
11793
|
+
/**
|
|
11794
|
+
* > The ScaleOutCluster API operation is phased out. You must call the node pool-related API operations to manage nodes. If you want to add worker nodes to an ACK cluster, call the ScaleClusterNodePool API operation. For more information, see [ScaleClusterNodePool](~~184928~~).
|
|
11795
|
+
*
|
|
11796
|
+
* @param request ScaleOutClusterRequest
|
|
11797
|
+
* @param headers map
|
|
11798
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
11799
|
+
* @return ScaleOutClusterResponse
|
|
11800
|
+
*/
|
|
10631
11801
|
async scaleOutClusterWithOptions(ClusterId, request, headers, runtime) {
|
|
10632
11802
|
tea_util_1.default.validateModel(request);
|
|
10633
11803
|
let body = {};
|
|
@@ -10652,7 +11822,7 @@ class Client extends openapi_client_1.default {
|
|
|
10652
11822
|
if (!tea_util_1.default.isUnset(request.rdsInstances)) {
|
|
10653
11823
|
body["rds_instances"] = request.rdsInstances;
|
|
10654
11824
|
}
|
|
10655
|
-
if (!tea_util_1.default.isUnset(
|
|
11825
|
+
if (!tea_util_1.default.isUnset(request.runtime)) {
|
|
10656
11826
|
body["runtime"] = request.runtime;
|
|
10657
11827
|
}
|
|
10658
11828
|
if (!tea_util_1.default.isUnset(request.tags)) {
|
|
@@ -10711,10 +11881,60 @@ class Client extends openapi_client_1.default {
|
|
|
10711
11881
|
});
|
|
10712
11882
|
return $tea.cast(await this.callApi(params, req, runtime), new ScaleOutClusterResponse({}));
|
|
10713
11883
|
}
|
|
10714
|
-
|
|
11884
|
+
/**
|
|
11885
|
+
* > The ScaleOutCluster API operation is phased out. You must call the node pool-related API operations to manage nodes. If you want to add worker nodes to an ACK cluster, call the ScaleClusterNodePool API operation. For more information, see [ScaleClusterNodePool](~~184928~~).
|
|
11886
|
+
*
|
|
11887
|
+
* @param request ScaleOutClusterRequest
|
|
11888
|
+
* @return ScaleOutClusterResponse
|
|
11889
|
+
*/
|
|
11890
|
+
async scaleOutCluster(ClusterId, request) {
|
|
10715
11891
|
let runtime = new $Util.RuntimeOptions({});
|
|
10716
11892
|
let headers = {};
|
|
10717
|
-
return await this.
|
|
11893
|
+
return await this.scaleOutClusterWithOptions(ClusterId, request, headers, runtime);
|
|
11894
|
+
}
|
|
11895
|
+
async scanClusterVulsWithOptions(clusterId, headers, runtime) {
|
|
11896
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
11897
|
+
headers: headers,
|
|
11898
|
+
});
|
|
11899
|
+
let params = new $OpenApi.Params({
|
|
11900
|
+
action: "ScanClusterVuls",
|
|
11901
|
+
version: "2015-12-15",
|
|
11902
|
+
protocol: "HTTPS",
|
|
11903
|
+
pathname: `/clusters/${openapi_util_1.default.getEncodeParam(clusterId)}/vuls/scan`,
|
|
11904
|
+
method: "POST",
|
|
11905
|
+
authType: "AK",
|
|
11906
|
+
style: "ROA",
|
|
11907
|
+
reqBodyType: "json",
|
|
11908
|
+
bodyType: "json",
|
|
11909
|
+
});
|
|
11910
|
+
return $tea.cast(await this.callApi(params, req, runtime), new ScanClusterVulsResponse({}));
|
|
11911
|
+
}
|
|
11912
|
+
async scanClusterVuls(clusterId) {
|
|
11913
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
11914
|
+
let headers = {};
|
|
11915
|
+
return await this.scanClusterVulsWithOptions(clusterId, headers, runtime);
|
|
11916
|
+
}
|
|
11917
|
+
async startAlertWithOptions(ClusterId, headers, runtime) {
|
|
11918
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
11919
|
+
headers: headers,
|
|
11920
|
+
});
|
|
11921
|
+
let params = new $OpenApi.Params({
|
|
11922
|
+
action: "StartAlert",
|
|
11923
|
+
version: "2015-12-15",
|
|
11924
|
+
protocol: "HTTPS",
|
|
11925
|
+
pathname: `/alert/${openapi_util_1.default.getEncodeParam(ClusterId)}/alert_rule/start`,
|
|
11926
|
+
method: "POST",
|
|
11927
|
+
authType: "AK",
|
|
11928
|
+
style: "ROA",
|
|
11929
|
+
reqBodyType: "json",
|
|
11930
|
+
bodyType: "json",
|
|
11931
|
+
});
|
|
11932
|
+
return $tea.cast(await this.callApi(params, req, runtime), new StartAlertResponse({}));
|
|
11933
|
+
}
|
|
11934
|
+
async startAlert(ClusterId) {
|
|
11935
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
11936
|
+
let headers = {};
|
|
11937
|
+
return await this.startAlertWithOptions(ClusterId, headers, runtime);
|
|
10718
11938
|
}
|
|
10719
11939
|
async startWorkflowWithOptions(request, headers, runtime) {
|
|
10720
11940
|
tea_util_1.default.validateModel(request);
|
|
@@ -10793,10 +12013,54 @@ class Client extends openapi_client_1.default {
|
|
|
10793
12013
|
});
|
|
10794
12014
|
return $tea.cast(await this.callApi(params, req, runtime), new StartWorkflowResponse({}));
|
|
10795
12015
|
}
|
|
10796
|
-
async
|
|
12016
|
+
async startWorkflow(request) {
|
|
10797
12017
|
let runtime = new $Util.RuntimeOptions({});
|
|
10798
12018
|
let headers = {};
|
|
10799
|
-
return await this.
|
|
12019
|
+
return await this.startWorkflowWithOptions(request, headers, runtime);
|
|
12020
|
+
}
|
|
12021
|
+
async stopAlertWithOptions(ClusterId, headers, runtime) {
|
|
12022
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
12023
|
+
headers: headers,
|
|
12024
|
+
});
|
|
12025
|
+
let params = new $OpenApi.Params({
|
|
12026
|
+
action: "StopAlert",
|
|
12027
|
+
version: "2015-12-15",
|
|
12028
|
+
protocol: "HTTPS",
|
|
12029
|
+
pathname: `/alert/${openapi_util_1.default.getEncodeParam(ClusterId)}/alert_rule/stop`,
|
|
12030
|
+
method: "POST",
|
|
12031
|
+
authType: "AK",
|
|
12032
|
+
style: "ROA",
|
|
12033
|
+
reqBodyType: "json",
|
|
12034
|
+
bodyType: "json",
|
|
12035
|
+
});
|
|
12036
|
+
return $tea.cast(await this.callApi(params, req, runtime), new StopAlertResponse({}));
|
|
12037
|
+
}
|
|
12038
|
+
async stopAlert(ClusterId) {
|
|
12039
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
12040
|
+
let headers = {};
|
|
12041
|
+
return await this.stopAlertWithOptions(ClusterId, headers, runtime);
|
|
12042
|
+
}
|
|
12043
|
+
async syncClusterNodePoolWithOptions(ClusterId, headers, runtime) {
|
|
12044
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
12045
|
+
headers: headers,
|
|
12046
|
+
});
|
|
12047
|
+
let params = new $OpenApi.Params({
|
|
12048
|
+
action: "SyncClusterNodePool",
|
|
12049
|
+
version: "2015-12-15",
|
|
12050
|
+
protocol: "HTTPS",
|
|
12051
|
+
pathname: `/clusters/${openapi_util_1.default.getEncodeParam(ClusterId)}/sync_nodepools`,
|
|
12052
|
+
method: "POST",
|
|
12053
|
+
authType: "AK",
|
|
12054
|
+
style: "ROA",
|
|
12055
|
+
reqBodyType: "json",
|
|
12056
|
+
bodyType: "json",
|
|
12057
|
+
});
|
|
12058
|
+
return $tea.cast(await this.callApi(params, req, runtime), new SyncClusterNodePoolResponse({}));
|
|
12059
|
+
}
|
|
12060
|
+
async syncClusterNodePool(ClusterId) {
|
|
12061
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
12062
|
+
let headers = {};
|
|
12063
|
+
return await this.syncClusterNodePoolWithOptions(ClusterId, headers, runtime);
|
|
10800
12064
|
}
|
|
10801
12065
|
async tagResourcesWithOptions(request, headers, runtime) {
|
|
10802
12066
|
tea_util_1.default.validateModel(request);
|
|
@@ -10830,10 +12094,10 @@ class Client extends openapi_client_1.default {
|
|
|
10830
12094
|
});
|
|
10831
12095
|
return $tea.cast(await this.callApi(params, req, runtime), new TagResourcesResponse({}));
|
|
10832
12096
|
}
|
|
10833
|
-
async
|
|
12097
|
+
async tagResources(request) {
|
|
10834
12098
|
let runtime = new $Util.RuntimeOptions({});
|
|
10835
12099
|
let headers = {};
|
|
10836
|
-
return await this.
|
|
12100
|
+
return await this.tagResourcesWithOptions(request, headers, runtime);
|
|
10837
12101
|
}
|
|
10838
12102
|
async unInstallClusterAddonsWithOptions(ClusterId, request, headers, runtime) {
|
|
10839
12103
|
tea_util_1.default.validateModel(request);
|
|
@@ -10854,13 +12118,21 @@ class Client extends openapi_client_1.default {
|
|
|
10854
12118
|
});
|
|
10855
12119
|
return $tea.cast(await this.callApi(params, req, runtime), new UnInstallClusterAddonsResponse({}));
|
|
10856
12120
|
}
|
|
10857
|
-
async
|
|
12121
|
+
async unInstallClusterAddons(ClusterId, request) {
|
|
10858
12122
|
let runtime = new $Util.RuntimeOptions({});
|
|
10859
12123
|
let headers = {};
|
|
10860
|
-
return await this.
|
|
12124
|
+
return await this.unInstallClusterAddonsWithOptions(ClusterId, request, headers, runtime);
|
|
10861
12125
|
}
|
|
10862
|
-
async untagResourcesWithOptions(
|
|
10863
|
-
tea_util_1.default.validateModel(
|
|
12126
|
+
async untagResourcesWithOptions(tmpReq, headers, runtime) {
|
|
12127
|
+
tea_util_1.default.validateModel(tmpReq);
|
|
12128
|
+
let request = new UntagResourcesShrinkRequest({});
|
|
12129
|
+
openapi_util_1.default.convert(tmpReq, request);
|
|
12130
|
+
if (!tea_util_1.default.isUnset(tmpReq.resourceIds)) {
|
|
12131
|
+
request.resourceIdsShrink = openapi_util_1.default.arrayToStringWithSpecifiedStyle(tmpReq.resourceIds, "resource_ids", "json");
|
|
12132
|
+
}
|
|
12133
|
+
if (!tea_util_1.default.isUnset(tmpReq.tagKeys)) {
|
|
12134
|
+
request.tagKeysShrink = openapi_util_1.default.arrayToStringWithSpecifiedStyle(tmpReq.tagKeys, "tag_keys", "json");
|
|
12135
|
+
}
|
|
10864
12136
|
let query = {};
|
|
10865
12137
|
if (!tea_util_1.default.isUnset(request.all)) {
|
|
10866
12138
|
query["all"] = request.all;
|
|
@@ -10868,14 +12140,14 @@ class Client extends openapi_client_1.default {
|
|
|
10868
12140
|
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10869
12141
|
query["region_id"] = request.regionId;
|
|
10870
12142
|
}
|
|
10871
|
-
if (!tea_util_1.default.isUnset(request.
|
|
10872
|
-
query["resource_ids"] = request.
|
|
12143
|
+
if (!tea_util_1.default.isUnset(request.resourceIdsShrink)) {
|
|
12144
|
+
query["resource_ids"] = request.resourceIdsShrink;
|
|
10873
12145
|
}
|
|
10874
12146
|
if (!tea_util_1.default.isUnset(request.resourceType)) {
|
|
10875
12147
|
query["resource_type"] = request.resourceType;
|
|
10876
12148
|
}
|
|
10877
|
-
if (!tea_util_1.default.isUnset(request.
|
|
10878
|
-
query["tag_keys"] = request.
|
|
12149
|
+
if (!tea_util_1.default.isUnset(request.tagKeysShrink)) {
|
|
12150
|
+
query["tag_keys"] = request.tagKeysShrink;
|
|
10879
12151
|
}
|
|
10880
12152
|
let req = new $OpenApi.OpenApiRequest({
|
|
10881
12153
|
headers: headers,
|
|
@@ -10894,10 +12166,10 @@ class Client extends openapi_client_1.default {
|
|
|
10894
12166
|
});
|
|
10895
12167
|
return $tea.cast(await this.callApi(params, req, runtime), new UntagResourcesResponse({}));
|
|
10896
12168
|
}
|
|
10897
|
-
async
|
|
12169
|
+
async untagResources(request) {
|
|
10898
12170
|
let runtime = new $Util.RuntimeOptions({});
|
|
10899
12171
|
let headers = {};
|
|
10900
|
-
return await this.
|
|
12172
|
+
return await this.untagResourcesWithOptions(request, headers, runtime);
|
|
10901
12173
|
}
|
|
10902
12174
|
async updateContactGroupForAlertWithOptions(ClusterId, headers, runtime) {
|
|
10903
12175
|
let req = new $OpenApi.OpenApiRequest({
|
|
@@ -10916,11 +12188,58 @@ class Client extends openapi_client_1.default {
|
|
|
10916
12188
|
});
|
|
10917
12189
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateContactGroupForAlertResponse({}));
|
|
10918
12190
|
}
|
|
10919
|
-
async
|
|
12191
|
+
async updateContactGroupForAlert(ClusterId) {
|
|
10920
12192
|
let runtime = new $Util.RuntimeOptions({});
|
|
10921
12193
|
let headers = {};
|
|
10922
|
-
return await this.
|
|
12194
|
+
return await this.updateContactGroupForAlertWithOptions(ClusterId, headers, runtime);
|
|
12195
|
+
}
|
|
12196
|
+
async updateControlPlaneLogWithOptions(ClusterId, request, headers, runtime) {
|
|
12197
|
+
tea_util_1.default.validateModel(request);
|
|
12198
|
+
let body = {};
|
|
12199
|
+
if (!tea_util_1.default.isUnset(request.aliuid)) {
|
|
12200
|
+
body["aliuid"] = request.aliuid;
|
|
12201
|
+
}
|
|
12202
|
+
if (!tea_util_1.default.isUnset(request.components)) {
|
|
12203
|
+
body["components"] = request.components;
|
|
12204
|
+
}
|
|
12205
|
+
if (!tea_util_1.default.isUnset(request.logProject)) {
|
|
12206
|
+
body["log_project"] = request.logProject;
|
|
12207
|
+
}
|
|
12208
|
+
if (!tea_util_1.default.isUnset(request.logTtl)) {
|
|
12209
|
+
body["log_ttl"] = request.logTtl;
|
|
12210
|
+
}
|
|
12211
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
12212
|
+
headers: headers,
|
|
12213
|
+
body: openapi_util_1.default.parseToMap(body),
|
|
12214
|
+
});
|
|
12215
|
+
let params = new $OpenApi.Params({
|
|
12216
|
+
action: "UpdateControlPlaneLog",
|
|
12217
|
+
version: "2015-12-15",
|
|
12218
|
+
protocol: "HTTPS",
|
|
12219
|
+
pathname: `/clusters/${openapi_util_1.default.getEncodeParam(ClusterId)}/controlplanelog`,
|
|
12220
|
+
method: "PUT",
|
|
12221
|
+
authType: "AK",
|
|
12222
|
+
style: "ROA",
|
|
12223
|
+
reqBodyType: "json",
|
|
12224
|
+
bodyType: "none",
|
|
12225
|
+
});
|
|
12226
|
+
return $tea.cast(await this.callApi(params, req, runtime), new UpdateControlPlaneLogResponse({}));
|
|
10923
12227
|
}
|
|
12228
|
+
async updateControlPlaneLog(ClusterId, request) {
|
|
12229
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
12230
|
+
let headers = {};
|
|
12231
|
+
return await this.updateControlPlaneLogWithOptions(ClusterId, request, headers, runtime);
|
|
12232
|
+
}
|
|
12233
|
+
/**
|
|
12234
|
+
* >
|
|
12235
|
+
* * You can call this operation only with an Alibaba Cloud account.
|
|
12236
|
+
* * After you revoke the kubeconfig file of a cluster, the validity period of the kubeconfig file that you specified becomes invalid. You can call this API operation to specify the validity period again.
|
|
12237
|
+
*
|
|
12238
|
+
* @param request UpdateK8sClusterUserConfigExpireRequest
|
|
12239
|
+
* @param headers map
|
|
12240
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
12241
|
+
* @return UpdateK8sClusterUserConfigExpireResponse
|
|
12242
|
+
*/
|
|
10924
12243
|
async updateK8sClusterUserConfigExpireWithOptions(ClusterId, request, headers, runtime) {
|
|
10925
12244
|
tea_util_1.default.validateModel(request);
|
|
10926
12245
|
let body = {};
|
|
@@ -10947,10 +12266,18 @@ class Client extends openapi_client_1.default {
|
|
|
10947
12266
|
});
|
|
10948
12267
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateK8sClusterUserConfigExpireResponse({}));
|
|
10949
12268
|
}
|
|
10950
|
-
|
|
12269
|
+
/**
|
|
12270
|
+
* >
|
|
12271
|
+
* * You can call this operation only with an Alibaba Cloud account.
|
|
12272
|
+
* * After you revoke the kubeconfig file of a cluster, the validity period of the kubeconfig file that you specified becomes invalid. You can call this API operation to specify the validity period again.
|
|
12273
|
+
*
|
|
12274
|
+
* @param request UpdateK8sClusterUserConfigExpireRequest
|
|
12275
|
+
* @return UpdateK8sClusterUserConfigExpireResponse
|
|
12276
|
+
*/
|
|
12277
|
+
async updateK8sClusterUserConfigExpire(ClusterId, request) {
|
|
10951
12278
|
let runtime = new $Util.RuntimeOptions({});
|
|
10952
12279
|
let headers = {};
|
|
10953
|
-
return await this.
|
|
12280
|
+
return await this.updateK8sClusterUserConfigExpireWithOptions(ClusterId, request, headers, runtime);
|
|
10954
12281
|
}
|
|
10955
12282
|
async updateTemplateWithOptions(TemplateId, request, headers, runtime) {
|
|
10956
12283
|
tea_util_1.default.validateModel(request);
|
|
@@ -10987,10 +12314,10 @@ class Client extends openapi_client_1.default {
|
|
|
10987
12314
|
});
|
|
10988
12315
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateTemplateResponse({}));
|
|
10989
12316
|
}
|
|
10990
|
-
async
|
|
12317
|
+
async updateTemplate(TemplateId, request) {
|
|
10991
12318
|
let runtime = new $Util.RuntimeOptions({});
|
|
10992
12319
|
let headers = {};
|
|
10993
|
-
return await this.
|
|
12320
|
+
return await this.updateTemplateWithOptions(TemplateId, request, headers, runtime);
|
|
10994
12321
|
}
|
|
10995
12322
|
async upgradeClusterWithOptions(ClusterId, request, headers, runtime) {
|
|
10996
12323
|
tea_util_1.default.validateModel(request);
|
|
@@ -10998,6 +12325,9 @@ class Client extends openapi_client_1.default {
|
|
|
10998
12325
|
if (!tea_util_1.default.isUnset(request.componentName)) {
|
|
10999
12326
|
body["component_name"] = request.componentName;
|
|
11000
12327
|
}
|
|
12328
|
+
if (!tea_util_1.default.isUnset(request.masterOnly)) {
|
|
12329
|
+
body["master_only"] = request.masterOnly;
|
|
12330
|
+
}
|
|
11001
12331
|
if (!tea_util_1.default.isUnset(request.nextVersion)) {
|
|
11002
12332
|
body["next_version"] = request.nextVersion;
|
|
11003
12333
|
}
|
|
@@ -11021,10 +12351,10 @@ class Client extends openapi_client_1.default {
|
|
|
11021
12351
|
});
|
|
11022
12352
|
return $tea.cast(await this.callApi(params, req, runtime), new UpgradeClusterResponse({}));
|
|
11023
12353
|
}
|
|
11024
|
-
async
|
|
12354
|
+
async upgradeCluster(ClusterId, request) {
|
|
11025
12355
|
let runtime = new $Util.RuntimeOptions({});
|
|
11026
12356
|
let headers = {};
|
|
11027
|
-
return await this.
|
|
12357
|
+
return await this.upgradeClusterWithOptions(ClusterId, request, headers, runtime);
|
|
11028
12358
|
}
|
|
11029
12359
|
async upgradeClusterAddonsWithOptions(ClusterId, request, headers, runtime) {
|
|
11030
12360
|
tea_util_1.default.validateModel(request);
|
|
@@ -11045,6 +12375,62 @@ class Client extends openapi_client_1.default {
|
|
|
11045
12375
|
});
|
|
11046
12376
|
return $tea.cast(await this.callApi(params, req, runtime), new UpgradeClusterAddonsResponse({}));
|
|
11047
12377
|
}
|
|
12378
|
+
async upgradeClusterAddons(ClusterId, request) {
|
|
12379
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
12380
|
+
let headers = {};
|
|
12381
|
+
return await this.upgradeClusterAddonsWithOptions(ClusterId, request, headers, runtime);
|
|
12382
|
+
}
|
|
12383
|
+
/**
|
|
12384
|
+
* You can call the UpgradeClusterNodepool operation to update the Kubernetes version, OS version, or container runtime version of the nodes in a node pool.
|
|
12385
|
+
*
|
|
12386
|
+
* @param request UpgradeClusterNodepoolRequest
|
|
12387
|
+
* @param headers map
|
|
12388
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
12389
|
+
* @return UpgradeClusterNodepoolResponse
|
|
12390
|
+
*/
|
|
12391
|
+
async upgradeClusterNodepoolWithOptions(ClusterId, NodepoolId, request, headers, runtime) {
|
|
12392
|
+
tea_util_1.default.validateModel(request);
|
|
12393
|
+
let body = {};
|
|
12394
|
+
if (!tea_util_1.default.isUnset(request.imageId)) {
|
|
12395
|
+
body["image_id"] = request.imageId;
|
|
12396
|
+
}
|
|
12397
|
+
if (!tea_util_1.default.isUnset(request.kubernetesVersion)) {
|
|
12398
|
+
body["kubernetes_version"] = request.kubernetesVersion;
|
|
12399
|
+
}
|
|
12400
|
+
if (!tea_util_1.default.isUnset(request.runtimeType)) {
|
|
12401
|
+
body["runtime_type"] = request.runtimeType;
|
|
12402
|
+
}
|
|
12403
|
+
if (!tea_util_1.default.isUnset(request.runtimeVersion)) {
|
|
12404
|
+
body["runtime_version"] = request.runtimeVersion;
|
|
12405
|
+
}
|
|
12406
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
12407
|
+
headers: headers,
|
|
12408
|
+
body: openapi_util_1.default.parseToMap(body),
|
|
12409
|
+
});
|
|
12410
|
+
let params = new $OpenApi.Params({
|
|
12411
|
+
action: "UpgradeClusterNodepool",
|
|
12412
|
+
version: "2015-12-15",
|
|
12413
|
+
protocol: "HTTPS",
|
|
12414
|
+
pathname: `/clusters/${openapi_util_1.default.getEncodeParam(ClusterId)}/nodepools/${openapi_util_1.default.getEncodeParam(NodepoolId)}/upgrade`,
|
|
12415
|
+
method: "POST",
|
|
12416
|
+
authType: "AK",
|
|
12417
|
+
style: "ROA",
|
|
12418
|
+
reqBodyType: "json",
|
|
12419
|
+
bodyType: "json",
|
|
12420
|
+
});
|
|
12421
|
+
return $tea.cast(await this.callApi(params, req, runtime), new UpgradeClusterNodepoolResponse({}));
|
|
12422
|
+
}
|
|
12423
|
+
/**
|
|
12424
|
+
* You can call the UpgradeClusterNodepool operation to update the Kubernetes version, OS version, or container runtime version of the nodes in a node pool.
|
|
12425
|
+
*
|
|
12426
|
+
* @param request UpgradeClusterNodepoolRequest
|
|
12427
|
+
* @return UpgradeClusterNodepoolResponse
|
|
12428
|
+
*/
|
|
12429
|
+
async upgradeClusterNodepool(ClusterId, NodepoolId, request) {
|
|
12430
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
12431
|
+
let headers = {};
|
|
12432
|
+
return await this.upgradeClusterNodepoolWithOptions(ClusterId, NodepoolId, request, headers, runtime);
|
|
12433
|
+
}
|
|
11048
12434
|
}
|
|
11049
12435
|
exports.default = Client;
|
|
11050
12436
|
//# sourceMappingURL=client.js.map
|