/
ecs_client.go
1651 lines (1431 loc) · 69.2 KB
/
ecs_client.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
package v2
import (
httpclient "github.com/huaweicloud/huaweicloud-sdk-go-v3/core"
"github.com/huaweicloud/huaweicloud-sdk-go-v3/core/invoker"
"github.com/huaweicloud/huaweicloud-sdk-go-v3/services/ecs/v2/model"
)
type EcsClient struct {
HcClient *httpclient.HcHttpClient
}
func NewEcsClient(hcClient *httpclient.HcHttpClient) *EcsClient {
return &EcsClient{HcClient: hcClient}
}
func EcsClientBuilder() *httpclient.HcHttpClientBuilder {
builder := httpclient.NewHcHttpClientBuilder()
return builder
}
// AddServerGroupMember 添加云服务器组成员
//
// 将云服务器加入云服务器组。添加成功后,如果该云服务器组是反亲和性策略的,则该云服务器与云服务器组中的其他成员尽量分散地创建在不同主机上。如果该云服务器时故障域类型的,则该云服务器会拥有故障域属性。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) AddServerGroupMember(request *model.AddServerGroupMemberRequest) (*model.AddServerGroupMemberResponse, error) {
requestDef := GenReqDefForAddServerGroupMember()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.AddServerGroupMemberResponse), nil
}
}
// AddServerGroupMemberInvoker 添加云服务器组成员
func (c *EcsClient) AddServerGroupMemberInvoker(request *model.AddServerGroupMemberRequest) *AddServerGroupMemberInvoker {
requestDef := GenReqDefForAddServerGroupMember()
return &AddServerGroupMemberInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// AssociateServerVirtualIp 云服务器网卡配置虚拟IP地址
//
// 虚拟IP地址用于为网卡提供第二个IP地址,同时支持与多个弹性云服务器的网卡绑定,从而实现多个弹性云服务器之间的高可用性。
//
// 该接口用于给云服务器网卡配置虚拟IP地址:
//
// - 当指定的IP地址是一个不存在的虚拟IP地址时,系统会创建该虚拟IP,并绑定至对应网卡。
//
// - 当指定的IP地址是一个已经创建好的私有IP时,系统会将指定的网卡和虚拟IP绑定。如果该IP的device_owner为空,则仅支持VPC内二三层通信;如果该IP的device_owner为neutron:VIP_PORT,则支持VPC内二三层通信、VPC之间对等连接访问,以及弹性公网IP、VPN、云专线等Internet接入。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) AssociateServerVirtualIp(request *model.AssociateServerVirtualIpRequest) (*model.AssociateServerVirtualIpResponse, error) {
requestDef := GenReqDefForAssociateServerVirtualIp()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.AssociateServerVirtualIpResponse), nil
}
}
// AssociateServerVirtualIpInvoker 云服务器网卡配置虚拟IP地址
func (c *EcsClient) AssociateServerVirtualIpInvoker(request *model.AssociateServerVirtualIpRequest) *AssociateServerVirtualIpInvoker {
requestDef := GenReqDefForAssociateServerVirtualIp()
return &AssociateServerVirtualIpInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// AttachServerVolume 弹性云服务器挂载磁盘
//
// 把磁盘挂载到弹性云服务器上。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) AttachServerVolume(request *model.AttachServerVolumeRequest) (*model.AttachServerVolumeResponse, error) {
requestDef := GenReqDefForAttachServerVolume()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.AttachServerVolumeResponse), nil
}
}
// AttachServerVolumeInvoker 弹性云服务器挂载磁盘
func (c *EcsClient) AttachServerVolumeInvoker(request *model.AttachServerVolumeRequest) *AttachServerVolumeInvoker {
requestDef := GenReqDefForAttachServerVolume()
return &AttachServerVolumeInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// BatchAddServerNics 批量添加云服务器网卡
//
// 给云服务器添加一张或多张网卡。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) BatchAddServerNics(request *model.BatchAddServerNicsRequest) (*model.BatchAddServerNicsResponse, error) {
requestDef := GenReqDefForBatchAddServerNics()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.BatchAddServerNicsResponse), nil
}
}
// BatchAddServerNicsInvoker 批量添加云服务器网卡
func (c *EcsClient) BatchAddServerNicsInvoker(request *model.BatchAddServerNicsRequest) *BatchAddServerNicsInvoker {
requestDef := GenReqDefForBatchAddServerNics()
return &BatchAddServerNicsInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// BatchAttachSharableVolumes 批量挂载指定共享盘
//
// 将指定的共享磁盘一次性挂载到多个弹性云服务器,实现批量挂载。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) BatchAttachSharableVolumes(request *model.BatchAttachSharableVolumesRequest) (*model.BatchAttachSharableVolumesResponse, error) {
requestDef := GenReqDefForBatchAttachSharableVolumes()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.BatchAttachSharableVolumesResponse), nil
}
}
// BatchAttachSharableVolumesInvoker 批量挂载指定共享盘
func (c *EcsClient) BatchAttachSharableVolumesInvoker(request *model.BatchAttachSharableVolumesRequest) *BatchAttachSharableVolumesInvoker {
requestDef := GenReqDefForBatchAttachSharableVolumes()
return &BatchAttachSharableVolumesInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// BatchCreateServerTags 批量添加云服务器标签
//
// - 为指定云服务器批量添加标签。
//
// - 标签管理服务TMS使用该接口批量管理云服务器的标签。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) BatchCreateServerTags(request *model.BatchCreateServerTagsRequest) (*model.BatchCreateServerTagsResponse, error) {
requestDef := GenReqDefForBatchCreateServerTags()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.BatchCreateServerTagsResponse), nil
}
}
// BatchCreateServerTagsInvoker 批量添加云服务器标签
func (c *EcsClient) BatchCreateServerTagsInvoker(request *model.BatchCreateServerTagsRequest) *BatchCreateServerTagsInvoker {
requestDef := GenReqDefForBatchCreateServerTags()
return &BatchCreateServerTagsInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// BatchDeleteServerNics 批量删除云服务器网卡
//
// 卸载并删除云服务器中的一张或多张网卡。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) BatchDeleteServerNics(request *model.BatchDeleteServerNicsRequest) (*model.BatchDeleteServerNicsResponse, error) {
requestDef := GenReqDefForBatchDeleteServerNics()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.BatchDeleteServerNicsResponse), nil
}
}
// BatchDeleteServerNicsInvoker 批量删除云服务器网卡
func (c *EcsClient) BatchDeleteServerNicsInvoker(request *model.BatchDeleteServerNicsRequest) *BatchDeleteServerNicsInvoker {
requestDef := GenReqDefForBatchDeleteServerNics()
return &BatchDeleteServerNicsInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// BatchDeleteServerTags 批量删除云服务器标签
//
// - 为指定云服务器批量删除标签。
//
// - 标签管理服务TMS使用该接口批量管理云服务器的标签。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) BatchDeleteServerTags(request *model.BatchDeleteServerTagsRequest) (*model.BatchDeleteServerTagsResponse, error) {
requestDef := GenReqDefForBatchDeleteServerTags()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.BatchDeleteServerTagsResponse), nil
}
}
// BatchDeleteServerTagsInvoker 批量删除云服务器标签
func (c *EcsClient) BatchDeleteServerTagsInvoker(request *model.BatchDeleteServerTagsRequest) *BatchDeleteServerTagsInvoker {
requestDef := GenReqDefForBatchDeleteServerTags()
return &BatchDeleteServerTagsInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// BatchRebootServers 批量重启云服务器
//
// 根据给定的云服务器ID列表,批量重启云服务器,一次最多可以重启1000台。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) BatchRebootServers(request *model.BatchRebootServersRequest) (*model.BatchRebootServersResponse, error) {
requestDef := GenReqDefForBatchRebootServers()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.BatchRebootServersResponse), nil
}
}
// BatchRebootServersInvoker 批量重启云服务器
func (c *EcsClient) BatchRebootServersInvoker(request *model.BatchRebootServersRequest) *BatchRebootServersInvoker {
requestDef := GenReqDefForBatchRebootServers()
return &BatchRebootServersInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// BatchResetServersPassword 批量重置弹性云服务器密码
//
// 批量重置弹性云服务器管理帐号(root用户或Administrator用户)的密码。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) BatchResetServersPassword(request *model.BatchResetServersPasswordRequest) (*model.BatchResetServersPasswordResponse, error) {
requestDef := GenReqDefForBatchResetServersPassword()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.BatchResetServersPasswordResponse), nil
}
}
// BatchResetServersPasswordInvoker 批量重置弹性云服务器密码
func (c *EcsClient) BatchResetServersPasswordInvoker(request *model.BatchResetServersPasswordRequest) *BatchResetServersPasswordInvoker {
requestDef := GenReqDefForBatchResetServersPassword()
return &BatchResetServersPasswordInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// BatchStartServers 批量启动云服务器
//
// 根据给定的云服务器ID列表,批量启动云服务器,一次最多可以启动1000台。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) BatchStartServers(request *model.BatchStartServersRequest) (*model.BatchStartServersResponse, error) {
requestDef := GenReqDefForBatchStartServers()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.BatchStartServersResponse), nil
}
}
// BatchStartServersInvoker 批量启动云服务器
func (c *EcsClient) BatchStartServersInvoker(request *model.BatchStartServersRequest) *BatchStartServersInvoker {
requestDef := GenReqDefForBatchStartServers()
return &BatchStartServersInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// BatchStopServers 批量关闭云服务器
//
// 根据给定的云服务器ID列表,批量关闭云服务器,一次最多可以关闭1000台。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) BatchStopServers(request *model.BatchStopServersRequest) (*model.BatchStopServersResponse, error) {
requestDef := GenReqDefForBatchStopServers()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.BatchStopServersResponse), nil
}
}
// BatchStopServersInvoker 批量关闭云服务器
func (c *EcsClient) BatchStopServersInvoker(request *model.BatchStopServersRequest) *BatchStopServersInvoker {
requestDef := GenReqDefForBatchStopServers()
return &BatchStopServersInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// BatchUpdateServersName 批量修改弹性云服务器
//
// 批量修改弹性云服务器信息。
// 当前仅支持批量修改云服务器名称,一次最多可以修改1000台。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) BatchUpdateServersName(request *model.BatchUpdateServersNameRequest) (*model.BatchUpdateServersNameResponse, error) {
requestDef := GenReqDefForBatchUpdateServersName()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.BatchUpdateServersNameResponse), nil
}
}
// BatchUpdateServersNameInvoker 批量修改弹性云服务器
func (c *EcsClient) BatchUpdateServersNameInvoker(request *model.BatchUpdateServersNameRequest) *BatchUpdateServersNameInvoker {
requestDef := GenReqDefForBatchUpdateServersName()
return &BatchUpdateServersNameInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// ChangeServerChargeMode 更换云服务器计费模式
//
// 更换云服务器的计费模式
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) ChangeServerChargeMode(request *model.ChangeServerChargeModeRequest) (*model.ChangeServerChargeModeResponse, error) {
requestDef := GenReqDefForChangeServerChargeMode()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.ChangeServerChargeModeResponse), nil
}
}
// ChangeServerChargeModeInvoker 更换云服务器计费模式
func (c *EcsClient) ChangeServerChargeModeInvoker(request *model.ChangeServerChargeModeRequest) *ChangeServerChargeModeInvoker {
requestDef := GenReqDefForChangeServerChargeMode()
return &ChangeServerChargeModeInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// ChangeServerOsWithCloudInit 切换弹性云服务器操作系统(安装Cloud init)
//
// 切换弹性云服务器操作系统。支持弹性云服务器数据盘不变的情况下,使用新镜像重装系统盘。
//
// 调用该接口后,系统将卸载系统盘,然后使用新镜像重新创建系统盘,并挂载至弹性云服务器,实现切换操作系统功能。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) ChangeServerOsWithCloudInit(request *model.ChangeServerOsWithCloudInitRequest) (*model.ChangeServerOsWithCloudInitResponse, error) {
requestDef := GenReqDefForChangeServerOsWithCloudInit()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.ChangeServerOsWithCloudInitResponse), nil
}
}
// ChangeServerOsWithCloudInitInvoker 切换弹性云服务器操作系统(安装Cloud init)
func (c *EcsClient) ChangeServerOsWithCloudInitInvoker(request *model.ChangeServerOsWithCloudInitRequest) *ChangeServerOsWithCloudInitInvoker {
requestDef := GenReqDefForChangeServerOsWithCloudInit()
return &ChangeServerOsWithCloudInitInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// ChangeServerOsWithoutCloudInit 切换弹性云服务器操作系统(未安装Cloud init)
//
// 切换弹性云服务器操作系统。
//
// 该接口支持未安装Cloud-init或Cloudbase-init的镜像使用。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) ChangeServerOsWithoutCloudInit(request *model.ChangeServerOsWithoutCloudInitRequest) (*model.ChangeServerOsWithoutCloudInitResponse, error) {
requestDef := GenReqDefForChangeServerOsWithoutCloudInit()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.ChangeServerOsWithoutCloudInitResponse), nil
}
}
// ChangeServerOsWithoutCloudInitInvoker 切换弹性云服务器操作系统(未安装Cloud init)
func (c *EcsClient) ChangeServerOsWithoutCloudInitInvoker(request *model.ChangeServerOsWithoutCloudInitRequest) *ChangeServerOsWithoutCloudInitInvoker {
requestDef := GenReqDefForChangeServerOsWithoutCloudInit()
return &ChangeServerOsWithoutCloudInitInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// ChangeVpc 云服务器切换虚拟私有云
//
// 云服务器切换虚拟私有云。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) ChangeVpc(request *model.ChangeVpcRequest) (*model.ChangeVpcResponse, error) {
requestDef := GenReqDefForChangeVpc()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.ChangeVpcResponse), nil
}
}
// ChangeVpcInvoker 云服务器切换虚拟私有云
func (c *EcsClient) ChangeVpcInvoker(request *model.ChangeVpcRequest) *ChangeVpcInvoker {
requestDef := GenReqDefForChangeVpc()
return &ChangeVpcInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// CreatePostPaidServers 创建云服务器(按需)
//
// 创建一台或多台[按需付费](https://support.huaweicloud.com/productdesc-ecs/ecs_01_0065.html)方式的云服务器。
//
// 弹性云服务器的登录鉴权方式包括两种:密钥对、密码。为安全起见,推荐使用密钥对方式。
//
// - 密钥对
// 密钥对指使用密钥对作为弹性云服务器的鉴权方式。
// 接口调用方法:使用key_name字段,指定弹性云服务器登录时使用的密钥文件。
//
// - 密码
// 密码指使用设置初始密码方式作为弹性云服务器的鉴权方式,此时,您可以通过用户名密码方式登录弹性云服务器,Linux操作系统时为root用户的初始密码,Windows操作系统时为Administrator用户的初始密码。
//
// 接口调用方法:使用adminPass字段,指定管理员帐号的初始登录密码。对于镜像已安装Cloud-init的Linux云服务器,如果需要使用密文密码,可以使用user_data字段进行密码注入。
//
// > 对于安装Cloud-init镜像的Linux云服务器云主机,若指定user_data字段,则adminPass字段无效。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) CreatePostPaidServers(request *model.CreatePostPaidServersRequest) (*model.CreatePostPaidServersResponse, error) {
requestDef := GenReqDefForCreatePostPaidServers()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.CreatePostPaidServersResponse), nil
}
}
// CreatePostPaidServersInvoker 创建云服务器(按需)
func (c *EcsClient) CreatePostPaidServersInvoker(request *model.CreatePostPaidServersRequest) *CreatePostPaidServersInvoker {
requestDef := GenReqDefForCreatePostPaidServers()
return &CreatePostPaidServersInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// CreateServerGroup 创建云服务器组
//
// 创建弹性云服务器组。
//
// 与原生的创建云服务器组接口不同之处在于该接口支持企业项目细粒度权限的校验。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) CreateServerGroup(request *model.CreateServerGroupRequest) (*model.CreateServerGroupResponse, error) {
requestDef := GenReqDefForCreateServerGroup()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.CreateServerGroupResponse), nil
}
}
// CreateServerGroupInvoker 创建云服务器组
func (c *EcsClient) CreateServerGroupInvoker(request *model.CreateServerGroupRequest) *CreateServerGroupInvoker {
requestDef := GenReqDefForCreateServerGroup()
return &CreateServerGroupInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// CreateServers 创建云服务器
//
// 创建一台或多台云服务器。
//
// 指该接口兼容《弹性云服务器接口参考》创建云服务器v1的功能,同时合入新功能,支持创建[包年/包月](https://support.huaweicloud.com/productdesc-ecs/ecs_01_0065.html)的弹性云服务器。
//
// 弹性云服务器的登录鉴权方式包括两种:密钥对、密码。为安全起见,推荐使用密钥对方式。
//
// - 密钥对
//
// 指使用密钥对作为弹性云服务器的鉴权方式。
//
// 接口调用方法:使用key_name字段,指定弹性云服务器登录时使用的密钥文件。
//
// - 密码
//
// 指使用设置初始密码方式作为弹性云服务器的鉴权方式,此时,您可以通过用户名密码方式登录弹性云服务器,Linux操作系统时为root用户的初始密码,Windows操作系统时为Administrator用户的初始密码。
//
// 接口调用方法:使用adminPass字段,指定管理员帐号的初始登录密码。对于镜像已安装Cloud-init的Linux云服务器,如果需要使用密文密码,可以使用user_data字段进行密码注入。
//
// > 对于安装Cloud-init镜像的Linux云服务器云主机,若指定user_data字段,则adminPass字段无效。
//
// 购买操作示例:
// - [使用API购买ECS过程中常见问题及处理方法](https://support.huaweicloud.com/api-ecs/ecs_04_0007.html)
// - [获取Token并检验Token的有效期 ](https://support.huaweicloud.com/api-ecs/ecs_04_0008.html)
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) CreateServers(request *model.CreateServersRequest) (*model.CreateServersResponse, error) {
requestDef := GenReqDefForCreateServers()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.CreateServersResponse), nil
}
}
// CreateServersInvoker 创建云服务器
func (c *EcsClient) CreateServersInvoker(request *model.CreateServersRequest) *CreateServersInvoker {
requestDef := GenReqDefForCreateServers()
return &CreateServersInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// DeleteServerGroup 删除云服务器组
//
// 删除云服务器组。
//
// 与原生的删除云服务器组接口不同之处在于该接口支持企业项目细粒度权限的校验。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) DeleteServerGroup(request *model.DeleteServerGroupRequest) (*model.DeleteServerGroupResponse, error) {
requestDef := GenReqDefForDeleteServerGroup()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.DeleteServerGroupResponse), nil
}
}
// DeleteServerGroupInvoker 删除云服务器组
func (c *EcsClient) DeleteServerGroupInvoker(request *model.DeleteServerGroupRequest) *DeleteServerGroupInvoker {
requestDef := GenReqDefForDeleteServerGroup()
return &DeleteServerGroupInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// DeleteServerGroupMember 删除云服务器组成员
//
// 将弹性云服务器移出云服务器组。移出后,该云服务器与云服务器组中的成员不再遵从反亲和策略。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) DeleteServerGroupMember(request *model.DeleteServerGroupMemberRequest) (*model.DeleteServerGroupMemberResponse, error) {
requestDef := GenReqDefForDeleteServerGroupMember()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.DeleteServerGroupMemberResponse), nil
}
}
// DeleteServerGroupMemberInvoker 删除云服务器组成员
func (c *EcsClient) DeleteServerGroupMemberInvoker(request *model.DeleteServerGroupMemberRequest) *DeleteServerGroupMemberInvoker {
requestDef := GenReqDefForDeleteServerGroupMember()
return &DeleteServerGroupMemberInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// DeleteServerMetadata 删除云服务器指定元数据
//
// 删除云服务器指定元数据。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) DeleteServerMetadata(request *model.DeleteServerMetadataRequest) (*model.DeleteServerMetadataResponse, error) {
requestDef := GenReqDefForDeleteServerMetadata()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.DeleteServerMetadataResponse), nil
}
}
// DeleteServerMetadataInvoker 删除云服务器指定元数据
func (c *EcsClient) DeleteServerMetadataInvoker(request *model.DeleteServerMetadataRequest) *DeleteServerMetadataInvoker {
requestDef := GenReqDefForDeleteServerMetadata()
return &DeleteServerMetadataInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// DeleteServerPassword 云服务器清除密码(企业项目)
//
// 清除Windows云服务器初始安装时系统生成的密码记录。清除密码后,不影响云服务器密码登录功能,但不能再使用获取密码功能来查询该云服务器密码。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) DeleteServerPassword(request *model.DeleteServerPasswordRequest) (*model.DeleteServerPasswordResponse, error) {
requestDef := GenReqDefForDeleteServerPassword()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.DeleteServerPasswordResponse), nil
}
}
// DeleteServerPasswordInvoker 云服务器清除密码(企业项目)
func (c *EcsClient) DeleteServerPasswordInvoker(request *model.DeleteServerPasswordRequest) *DeleteServerPasswordInvoker {
requestDef := GenReqDefForDeleteServerPassword()
return &DeleteServerPasswordInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// DeleteServers 删除云服务器
//
// 根据指定的云服务器ID列表,删除云服务器。
//
// 系统支持删除单台云服务器和批量删除多台云服务器操作,批量删除云服务器时,一次最多可以删除1000台。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) DeleteServers(request *model.DeleteServersRequest) (*model.DeleteServersResponse, error) {
requestDef := GenReqDefForDeleteServers()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.DeleteServersResponse), nil
}
}
// DeleteServersInvoker 删除云服务器
func (c *EcsClient) DeleteServersInvoker(request *model.DeleteServersRequest) *DeleteServersInvoker {
requestDef := GenReqDefForDeleteServers()
return &DeleteServersInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// DetachServerVolume 弹性云服务器卸载磁盘
//
// 从弹性云服务器中卸载磁盘。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) DetachServerVolume(request *model.DetachServerVolumeRequest) (*model.DetachServerVolumeResponse, error) {
requestDef := GenReqDefForDetachServerVolume()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.DetachServerVolumeResponse), nil
}
}
// DetachServerVolumeInvoker 弹性云服务器卸载磁盘
func (c *EcsClient) DetachServerVolumeInvoker(request *model.DetachServerVolumeRequest) *DetachServerVolumeInvoker {
requestDef := GenReqDefForDetachServerVolume()
return &DetachServerVolumeInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// DisassociateServerVirtualIp 云服务器网卡解绑虚拟IP地址
//
// 虚拟IP地址用于为网卡提供第二个IP地址,同时支持与多个弹性云服务器的网卡绑定,从而实现多个弹性云服务器之间的高可用性。
//
// 该接口用于解绑定弹性云服务器网卡的虚拟IP地址。解绑后,网卡不会被删除。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) DisassociateServerVirtualIp(request *model.DisassociateServerVirtualIpRequest) (*model.DisassociateServerVirtualIpResponse, error) {
requestDef := GenReqDefForDisassociateServerVirtualIp()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.DisassociateServerVirtualIpResponse), nil
}
}
// DisassociateServerVirtualIpInvoker 云服务器网卡解绑虚拟IP地址
func (c *EcsClient) DisassociateServerVirtualIpInvoker(request *model.DisassociateServerVirtualIpRequest) *DisassociateServerVirtualIpInvoker {
requestDef := GenReqDefForDisassociateServerVirtualIp()
return &DisassociateServerVirtualIpInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// ListFlavorSellPolicies 查询规格销售策略
//
// 查询规格销售策略。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) ListFlavorSellPolicies(request *model.ListFlavorSellPoliciesRequest) (*model.ListFlavorSellPoliciesResponse, error) {
requestDef := GenReqDefForListFlavorSellPolicies()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.ListFlavorSellPoliciesResponse), nil
}
}
// ListFlavorSellPoliciesInvoker 查询规格销售策略
func (c *EcsClient) ListFlavorSellPoliciesInvoker(request *model.ListFlavorSellPoliciesRequest) *ListFlavorSellPoliciesInvoker {
requestDef := GenReqDefForListFlavorSellPolicies()
return &ListFlavorSellPoliciesInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// ListFlavors 查询规格详情和规格扩展信息列表
//
// 查询云服务器规格详情信息和规格扩展信息列表。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) ListFlavors(request *model.ListFlavorsRequest) (*model.ListFlavorsResponse, error) {
requestDef := GenReqDefForListFlavors()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.ListFlavorsResponse), nil
}
}
// ListFlavorsInvoker 查询规格详情和规格扩展信息列表
func (c *EcsClient) ListFlavorsInvoker(request *model.ListFlavorsRequest) *ListFlavorsInvoker {
requestDef := GenReqDefForListFlavors()
return &ListFlavorsInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// ListResizeFlavors 查询云服务器规格变更支持列表
//
// 变更规格时,部分规格的云服务器之间不能互相变更。您可以通过本接口,通过指定弹性云服务器规格,查询该规格可以变更的规格列表。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) ListResizeFlavors(request *model.ListResizeFlavorsRequest) (*model.ListResizeFlavorsResponse, error) {
requestDef := GenReqDefForListResizeFlavors()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.ListResizeFlavorsResponse), nil
}
}
// ListResizeFlavorsInvoker 查询云服务器规格变更支持列表
func (c *EcsClient) ListResizeFlavorsInvoker(request *model.ListResizeFlavorsRequest) *ListResizeFlavorsInvoker {
requestDef := GenReqDefForListResizeFlavors()
return &ListResizeFlavorsInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// ListServerBlockDevices 查询弹性云服务器挂载磁盘列表详情信息
//
// 查询弹性云服务器挂载的磁盘信息。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) ListServerBlockDevices(request *model.ListServerBlockDevicesRequest) (*model.ListServerBlockDevicesResponse, error) {
requestDef := GenReqDefForListServerBlockDevices()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.ListServerBlockDevicesResponse), nil
}
}
// ListServerBlockDevicesInvoker 查询弹性云服务器挂载磁盘列表详情信息
func (c *EcsClient) ListServerBlockDevicesInvoker(request *model.ListServerBlockDevicesRequest) *ListServerBlockDevicesInvoker {
requestDef := GenReqDefForListServerBlockDevices()
return &ListServerBlockDevicesInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// ListServerGroups 查询云服务器组列表
//
// 查询弹性云服务器组。
//
// 与原生的创建云服务器组接口不同之处在于该接口支持企业项目细粒度权限的校验。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) ListServerGroups(request *model.ListServerGroupsRequest) (*model.ListServerGroupsResponse, error) {
requestDef := GenReqDefForListServerGroups()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.ListServerGroupsResponse), nil
}
}
// ListServerGroupsInvoker 查询云服务器组列表
func (c *EcsClient) ListServerGroupsInvoker(request *model.ListServerGroupsRequest) *ListServerGroupsInvoker {
requestDef := GenReqDefForListServerGroups()
return &ListServerGroupsInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// ListServerInterfaces 查询云服务器网卡信息
//
// 查询云服务器网卡信息。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) ListServerInterfaces(request *model.ListServerInterfacesRequest) (*model.ListServerInterfacesResponse, error) {
requestDef := GenReqDefForListServerInterfaces()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.ListServerInterfacesResponse), nil
}
}
// ListServerInterfacesInvoker 查询云服务器网卡信息
func (c *EcsClient) ListServerInterfacesInvoker(request *model.ListServerInterfacesRequest) *ListServerInterfacesInvoker {
requestDef := GenReqDefForListServerInterfaces()
return &ListServerInterfacesInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// ListServerTags 查询项目标签
//
// 项目(Project)用于将OpenStack的资源(计算资源、存储资源和网络资源)进行分组和隔离。项目可以是一个部门或者一个项目组。一个帐户中可以创建多个项目。
//
// 该接口用于查询用户在指定项目所使用的全部标签。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) ListServerTags(request *model.ListServerTagsRequest) (*model.ListServerTagsResponse, error) {
requestDef := GenReqDefForListServerTags()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.ListServerTagsResponse), nil
}
}
// ListServerTagsInvoker 查询项目标签
func (c *EcsClient) ListServerTagsInvoker(request *model.ListServerTagsRequest) *ListServerTagsInvoker {
requestDef := GenReqDefForListServerTags()
return &ListServerTagsInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// Deprecated: This function is deprecated and will be removed in the future versions.
// ListServersByTag 按标签查询云服务器列表
//
// 使用标签过滤弹性云服务器,并返回云服务器使用的所有标签和资源列表。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) ListServersByTag(request *model.ListServersByTagRequest) (*model.ListServersByTagResponse, error) {
requestDef := GenReqDefForListServersByTag()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.ListServersByTagResponse), nil
}
}
// Deprecated: This function is deprecated and will be removed in the future versions.
// ListServersByTagInvoker 按标签查询云服务器列表
func (c *EcsClient) ListServersByTagInvoker(request *model.ListServersByTagRequest) *ListServersByTagInvoker {
requestDef := GenReqDefForListServersByTag()
return &ListServersByTagInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// ListServersDetails 查询云服务器详情列表
//
// 根据用户请求条件从数据库筛选、查询所有的弹性云服务器,并关联相关表获取到弹性云服务器的详细信息。
//
// 该接口支持查询弹性云服务器计费方式,以及是否被冻结。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) ListServersDetails(request *model.ListServersDetailsRequest) (*model.ListServersDetailsResponse, error) {
requestDef := GenReqDefForListServersDetails()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.ListServersDetailsResponse), nil
}
}
// ListServersDetailsInvoker 查询云服务器详情列表
func (c *EcsClient) ListServersDetailsInvoker(request *model.ListServersDetailsRequest) *ListServersDetailsInvoker {
requestDef := GenReqDefForListServersDetails()
return &ListServersDetailsInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// MigrateServer 冷迁移云服务器
//
// - 将部署在专属主机上的弹性云服务器迁移至其他专属主机。
// - 将部署在专属主机上的弹性云服务器迁移至公共资源池,即不再部署在专属主机上。
// - 将公共资源池的弹性云服务器迁移至专属主机上,成为专属主机上部署的弹性云服务器。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) MigrateServer(request *model.MigrateServerRequest) (*model.MigrateServerResponse, error) {
requestDef := GenReqDefForMigrateServer()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.MigrateServerResponse), nil
}
}
// MigrateServerInvoker 冷迁移云服务器
func (c *EcsClient) MigrateServerInvoker(request *model.MigrateServerRequest) *MigrateServerInvoker {
requestDef := GenReqDefForMigrateServer()
return &MigrateServerInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// NovaAssociateSecurityGroup 添加安全组
//
// 为弹性云服务器添加一个安全组。
//
// 添加多个安全组时,建议最多为弹性云服务器添加5个安全组。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) NovaAssociateSecurityGroup(request *model.NovaAssociateSecurityGroupRequest) (*model.NovaAssociateSecurityGroupResponse, error) {
requestDef := GenReqDefForNovaAssociateSecurityGroup()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.NovaAssociateSecurityGroupResponse), nil
}
}
// NovaAssociateSecurityGroupInvoker 添加安全组
func (c *EcsClient) NovaAssociateSecurityGroupInvoker(request *model.NovaAssociateSecurityGroupRequest) *NovaAssociateSecurityGroupInvoker {
requestDef := GenReqDefForNovaAssociateSecurityGroup()
return &NovaAssociateSecurityGroupInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// NovaAttachInterface 添加云服务器网卡
//
// 给云服务器添加一张网卡。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) NovaAttachInterface(request *model.NovaAttachInterfaceRequest) (*model.NovaAttachInterfaceResponse, error) {
requestDef := GenReqDefForNovaAttachInterface()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.NovaAttachInterfaceResponse), nil
}
}
// NovaAttachInterfaceInvoker 添加云服务器网卡
func (c *EcsClient) NovaAttachInterfaceInvoker(request *model.NovaAttachInterfaceRequest) *NovaAttachInterfaceInvoker {
requestDef := GenReqDefForNovaAttachInterface()
return &NovaAttachInterfaceInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// NovaCreateKeypair 创建和导入SSH密钥
//
// 创建SSH密钥,或把公钥导入系统,生成密钥对。
//
// 创建SSH密钥成功后,请把响应数据中的私钥内容保存到本地文件,用户使用该私钥登录云服务器云主机。为保证云服务器云主机器安全,私钥数据只能读取一次,请妥善保管。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) NovaCreateKeypair(request *model.NovaCreateKeypairRequest) (*model.NovaCreateKeypairResponse, error) {
requestDef := GenReqDefForNovaCreateKeypair()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.NovaCreateKeypairResponse), nil
}
}
// NovaCreateKeypairInvoker 创建和导入SSH密钥
func (c *EcsClient) NovaCreateKeypairInvoker(request *model.NovaCreateKeypairRequest) *NovaCreateKeypairInvoker {
requestDef := GenReqDefForNovaCreateKeypair()
return &NovaCreateKeypairInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// NovaCreateServers 创建云服务器
//
// 创建一台弹性云服务器。
//
// 弹性云服务器创建完成后,如需开启自动恢复功能,可以调用配置云服务器自动恢复的接口,具体使用请参见管理云服务器自动恢复动作。
//
// 该接口在云服务器创建失败后不支持自动回滚。若需要自动回滚能力,可以调用POST /v1/{project_id}/cloudservers接口,具体使用请参见创建云服务器(按需)。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) NovaCreateServers(request *model.NovaCreateServersRequest) (*model.NovaCreateServersResponse, error) {
requestDef := GenReqDefForNovaCreateServers()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.NovaCreateServersResponse), nil
}
}
// NovaCreateServersInvoker 创建云服务器
func (c *EcsClient) NovaCreateServersInvoker(request *model.NovaCreateServersRequest) *NovaCreateServersInvoker {
requestDef := GenReqDefForNovaCreateServers()
return &NovaCreateServersInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// NovaDeleteKeypair 删除SSH密钥
//
// 根据SSH密钥的名称,删除指定SSH密钥。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) NovaDeleteKeypair(request *model.NovaDeleteKeypairRequest) (*model.NovaDeleteKeypairResponse, error) {
requestDef := GenReqDefForNovaDeleteKeypair()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.NovaDeleteKeypairResponse), nil
}
}
// NovaDeleteKeypairInvoker 删除SSH密钥
func (c *EcsClient) NovaDeleteKeypairInvoker(request *model.NovaDeleteKeypairRequest) *NovaDeleteKeypairInvoker {
requestDef := GenReqDefForNovaDeleteKeypair()
return &NovaDeleteKeypairInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}
// NovaDeleteServer 删除云服务器
//
// 删除一台云服务器。
//
// Please refer to HUAWEI cloud API Explorer for details.
func (c *EcsClient) NovaDeleteServer(request *model.NovaDeleteServerRequest) (*model.NovaDeleteServerResponse, error) {
requestDef := GenReqDefForNovaDeleteServer()
if resp, err := c.HcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp.(*model.NovaDeleteServerResponse), nil
}
}
// NovaDeleteServerInvoker 删除云服务器
func (c *EcsClient) NovaDeleteServerInvoker(request *model.NovaDeleteServerRequest) *NovaDeleteServerInvoker {
requestDef := GenReqDefForNovaDeleteServer()
return &NovaDeleteServerInvoker{invoker.NewBaseInvoker(c.HcClient, request, requestDef)}
}