args := &api.CreateInstanceArgs{
    // 选择实例创建镜像ID 
    ImageId: "m-DpgNg8lO",
	// 选择付款方式，可以选择预付费或后付费 
	Billing: api.Billing{
        PaymentTiming: api.PaymentTimingPostPaid,
	},
    // 选择实例类型，可以选择N1, N2, N3等 
    InstanceType:        api.InstanceTypeN1,
    // 选择1核CPU 
    CpuCount:            1,
    // 选择1GB内存 
    MemoryCapacityInGB:  1,
    // 选择40GB磁盘空间 
    RootDiskSizeInGb:    40,
    // 选择待创建的实例系统盘介质为HP1 
    RootDiskStorageType: api.StorageTypeCloudHP1,
    // 临时盘数据盘大小
    EphemeralDisks        []EphemeralDisk  "ephemeralDisks"
    // 选择创建100GB大小SSD类型CDS磁盘并挂载到实例上 
    CreateCdsList: []api.CreateCdsModel{
		{
			StorageType: api.StorageTypeSSD,
			CdsSizeInGB: 100,
		},
	},
    // 设置管理员密码 
    AdminPass: "123qaz!@#",
	// 设置实例名称 
	Name:      "terraform_sdkTest",
    // 实例主机名,可选参数,若不选则主机名和实例名称保持一致(实例名称不包含中文名时)
    // 仅支持小写字母、数字以及- . 特殊字符，不可连续使用特殊符号，不支持特殊符号开头或结尾，长度2-64
    Hostname:        "your-choose-instance-hostname",
    // 设置是否自动生成hostname和name有序后缀 是:true 否:false
    AutoSeqSuffix:        false,
    // 设置是否开启hostname domain 是：true 否：false
    IsOpenHostnameDomain:   false,
	// 设置创建BCC使用的网络带宽大小
    NetWorkCapacityInMbps int              networkCapacityInMbps
    // 设置需要创建BCC使用的DCC服务器id
    DedicateHostId        string           "dedicatedHostId"
    // 设置待查询的竞价实例的购买个数
    PurchaseCount         int              purchaseCount
    // 设置可用区
    ZoneName              string           "zoneName"
    // 指定子网和安全组创建，要求子网和安全组必须同时指定或同时不指定，
    // 同时指定的子网和安全组必须同属于一个VPC，都不指定会使用默认子网和默认安全组。
    // 设置创建BCC使用的子网
    SubnetId              string           "subnetId"
    // 设置创建BCC使用的安全组
    SecurityGroupId       string           "securityGroupId"
    // 设置创建BCC使用的企业安全组，不允许同时设置企业安全组和普通安全组
    EnterpriseSecurityGroupId       string           "enterpriseSecurityGroupId"
    // 设置需要创建GPU卡信息
    GpuCard               string           "gpuCard"
    // 设置需要创建FPGA卡信息
    FpgaCard              string           "fpgaCard"
    // 设置GPU卡或FPGA卡数量
    CardCount             string           "cardCount"
    // 设置按月付费或者按年付费 月是"month",年是"year"
    AutoRenewTimeUnit     string           "autoRenewTimeUnit"
    // 设置自动续费的时间 按月是1-9 按年是 1-3
    AutoRenewTime         int              autoRenewTime
    // cds是否自动续费 是:true 否:false
    CdsAutoRenew          bool             cdsAutoRenew
    // 待创建实例指定的标签是否需要和已有标签键进行关联，默认为false。注意值为true时要保证该标签键已存在
    RelationTag           bool             relationTag
    // 待创建的标签列表
    Tags                  []model.TagModel tags
    // 指定实例所在的部署集id
    DeployId              string           "deployId"
    // 指定实例所在的部署集id 列表
	DeployIdList          []string         "deployIdList"
    // 设置释放保护 默认0不启用，1启用
    DetetionProtection    int              "deletionProtection"
    // 设置要绑定的密钥对ID
    KeypairId             string           "keypairId"
    // 设置要绑定的自动快照策略ID
    AspId                 string           "aspId"
    // 公网带宽计费方式，若不指定internetChargeType，默认付费方式同BCC，预付费默认为包年包月按带宽，后付费默认为按使用带宽计费。（BANDWIDTH_PREPAID：预付费按带宽结算；TRAFFIC_POSTPAID_BY_HOUR：流量按小时后付费；BANDWIDTH_POSTPAID_BY_HOUR：带宽按小时后付费）
    InternetChargeType    string           "internetChargeType"
    // 设置内网IP
    InternalIps           []string         internalIps
    // 使用 uuid 生成一个长度不超过64位的ASCII字符串
    ClientToken           string           "random-uuid"
    //创建实例支持幂等的token
    RequestToken     string  "requestToken"
}

// 若要生成预付费实例，可以按以下配置生成一个月的预付费实例
args.Billing = api.Billing{
		PaymentTiming: api.PaymentTimingPrePaid,
		Reservation: &api.Reservation{
            ReservationLength:   1,
            ReservationTimeUnit: "month",
        }
	}

// 若要设置自动续费，可以按以下参数设置一年内自动续费
args.AutoRenewTimeUnit = "year"
args.AutoRenewTime = 1

// 若要创建公网EIP，可以设置以下参数
args.networkCapacityInMbps = 1

// 若要一次创建多个相同配置的实例，可以设置以下参数
args.PurchaseCount = 2

result, err := client.CreateInstance(args)
if err != nil {
    fmt.Println("create instance failed:", err)
} else {
    fmt.Println("create instance success: ", result)
}

createInstanceBySpecArgs := &api.CreateInstanceBySpecArgs{
    // 选择实例创建镜像ID 
	ImageId:               "m-1PyVLtic",
    // 选择创建BCC的套餐规格
	Spec:                  "bcc.g2.c2m8",
    // 选择40GB磁盘空间 
    RootDiskSizeInGb:      40,
    // 选择待创建的实例系统盘介质为HP1 
    RootDiskStorageType:   api.StorageTypeCloudHP1,
    // 选择创建100GB大小SSD类型CDS磁盘并挂载到实例上 
    CreateCdsList: []api.CreateCdsModel{
		{
			StorageType: api.StorageTypeSSD,
			CdsSizeInGB: 100,
    	},
    },
    // 选择付款方式，可以选择预付费或后付费 
    Billing: api.Billing{
		PaymentTiming: api.PaymentTimingPostPaid,
    },
    Name:                  "sdkTest",
    // 实例主机名,可选参数,若不选则主机名和实例名称保持一致(实例名称不包含中文名时)
    // 仅支持小写字母、数字以及- . 特殊字符，不可连续使用特殊符号，不支持特殊符号开头或结尾，长度2-64
    Hostname:        "your-choose-instance-hostname",
    // 设置是否自动生成hostname和name有序后缀 是:true 否:false
    AutoSeqSuffix:        false,
    // 设置是否开启hostname domain 是：true 否：false
    IsOpenHostnameDomain:   false,
    AdminPass:             "123qaz!@#",
    // 临时盘数据盘大小
    EphemeralDisks        []EphemeralDisk  "ephemeralDisks"
    // 设置创建BCC使用的网络带宽大小
    NetWorkCapacityInMbps int              networkCapacityInMbps
    // 设置待查询的竞价实例的购买个数
    PurchaseCount         int              purchaseCount
    // 设置可用区
    ZoneName              string           "zoneName"
    // 指定子网和安全组创建，要求子网和安全组必须同时指定或同时不指定，
    // 同时指定的子网和安全组必须同属于一个VPC，都不指定会使用默认子网和默认安全组。
    // 设置创建BCC使用的子网
    SubnetId              string           "subnetId"
    // 设置创建BCC使用的安全组
    SecurityGroupId       string           "securityGroupId"
    // 设置创建BCC使用的企业安全组，不允许同时设置企业安全组和普通安全组
    EnterpriseSecurityGroupId       string           "enterpriseSecurityGroupId"
    // 设置按月付费或者按年付费 月是"month",年是"year"
    AutoRenewTimeUnit     string           "autoRenewTimeUnit"
    // 设置自动续费的时间 按月是1-9 按年是 1-3
    AutoRenewTime         int              autoRenewTime
    // cds是否自动续费 是:true 否:false
    CdsAutoRenew          bool             cdsAutoRenew
	// 指定实例所在的部署集id 列表
	DeployIdList          []string         "deployIdList"
    // 设置释放保护 默认0不启用，1启用
    DetetionProtection    int              "deletionProtection"
    // 待创建实例指定的标签是否需要和已有标签键进行关联，默认为false。注意值为true时要保证该标签键已存在
    RelationTag           bool             relationTag
    // 待创建的标签列表
    Tags                  []model.TagModel tags
    // 设置要绑定的密钥对ID
    KeypairId             string           "keypairId"
    // 设置要绑定的自动快照策略ID
    AspId                 string           "aspId"
    // 公网带宽计费方式，若不指定internetChargeType，默认付费方式同BCC，预付费默认为包年包月按带宽，后付费默认为按使用带宽计费。（BANDWIDTH_PREPAID：预付费按带宽结算；TRAFFIC_POSTPAID_BY_HOUR：流量按小时后付费；BANDWIDTH_POSTPAID_BY_HOUR：带宽按小时后付费）
    InternetChargeType    string           "internetChargeType"
    // 设置内网IP
    InternalIps           []string         internalIps
    // 使用 uuid 生成一个长度不超过64位的ASCII字符串
    ClientToken           string           "random-uuid"
	// 创建实例支持幂等的token,成功后永久有效
    RequestToken          string           "requestToken"

}
result, err := client.CreateInstanceBySpec(args)
if err != nil {
    fmt.Println("create instance failed:", err)
} else {
    fmt.Println("create instance success: ", result)
}

createInstanceV3Args := &api.CreateInstanceV3Args{
    // 选择创建BCC的套餐规格
	InstanceSpec: "bcc.ic3.c1m1",
    // 系统盘类型，大小
    // 选择40GB大小的Cloud_SSD_General类型磁盘作为系统盘
    SystemVolume: api.SystemVolume{
        StorageType: api.StorageTypeV3CloudSSDGeneral,
        VolumeSize:  40,
    },
    // 本地盘&CDS数据盘
    // 选择创建5GB大小Cloud_Premium类型CDS云磁盘并挂载到实例上 
    DataVolumes: []api.DataVolume{
        {
            StorageType: api.StorageTypeV3CloudPremium,
            VolumeSize:  5,
            // 快照ID，当磁盘类型属于CDS云磁盘时，此属性有效
            SnapshotId: "snapshotId",
            // 加密密钥，当磁盘类型属于CDS云磁盘时，此属性有效
            EncryptKey: "encryptKey",
        },
    },
    // 实例名称
    InstanceName: "sdkTest",
    // 实例购买数量
    PurchaseCount: 1,
    // 实例主机名,可选参数,若不选则主机名和实例名称保持一致(实例名称不包含中文名时)
    // 仅支持小写字母、数字以及- . 特殊字符，不可连续使用特殊符号，不支持特殊符号开头或结尾，长度2-64
    HostName: "hostName",
    // 设置是否开启hostname domain 是：true 否：false
    AutoSeqSuffix: false,
    // 设置是否开启hostname domain 是：true 否：false
    HostNameDomain: false,
    // 实例管理员密码
    Password: "123qaz!@#",
    // 选择付款方式，可以选择预付费：Prepaid，后付费：Postpaid，竞价付费：Spotpaid（选择竞价付费时需配置InstanceMarketOptions参数）
    // 选择购买时长1，默认单位：月
    Billing: api.Billing{
		PaymentTiming: api.PaymentTimingPrePaid,
		Reservation: &api.Reservation{
            ReservationLength: 1,
        },
    },
    // 设置可用区
    ZoneName: "zoneName"
    // 指定子网和安全组，要求子网和安全组必须同时指定或同时不指定，
    // 同时指定的子网和安全组必须同属于一个VPC，都不指定会使用默认子网和默认安全组。
    // 设置创建BCC使用的子网
    SubnetId: "subnetId"
    // 设置创建BCC使用的安全组
    SecurityGroupIds: []string{
        "securityGroup1",
        "securityGroup2",
    },
    // 联合购买资源CDS，EIP统一关联标签，默认：false
    AssociatedResourceTag: false,
    // 待创建的标签列表
    Tags: []model.TagModel{
        {
            TagKey:   "tagKey",
            TagValue: "tagValue",
        },
    },
    // 设置要绑定的密钥对ID
    KeypairId: "keypairId",
    // 设置自动续费的时间，单位：月
    // 取值范围：1,2,3,4,5,6,7,8,9,12,24,36
    AutoRenewTime: 1,
    // CDS数据盘是否自动续费 是:true 否:false
    CdsAutoRenew: true,
    // 设置要绑定的自动快照策略ID
    AutoSnapshotPolicyId: "autoSnapshotPolicyId",
    // 部署集
    DeploymentSetId: "deploymentSetId",
    // 镜像id
    ImageId: "imageId",
    // 竞价实例出价模型
    // SpotOption. 市场价: "market" 自定义："custom"
    // SpotPrice. 竞价实例出价金额，若是自定义出价，且出价金额小于市场价，则不允许创建。当spotOption='custom'时才有效。
    InstanceMarketOptions: api.InstanceMarketOptions{
        SpotOption: "custom",
        SpotPrice:  "spotPrice",
    },
    // 待创建实例是否开启ipv6，只有当镜像和子网都支持ipv6时才可开启，true表示开启，false表示关闭，不传表示自动适配镜像和子网的ipv6支持情况
    Ipv6: false,
    // 专属服务器ID
    DedicatedHostId: "dedicatedHostId",
    // 公网带宽
    // InternetMaxBandwidthOut. 设置创建BCC使用的网络带宽大小，单位为Mbps。必须为0~200之间的整数，为0表示不分配公网IP，默认为0Mbps
    // InternetChargeType. 公网带宽计费方式，若不指定internetChargeType，默认付费方式同BCC，预付费默认为包年包月按带宽，
    // 后付费默认为按使用带宽计费。（BANDWIDTH_PREPAID：预付费按带宽结算；TRAFFIC_POSTPAID_BY_HOUR：流量按小时后付费；
    // BANDWIDTH_POSTPAID_BY_HOUR：带宽按小时后付费）
    InternetAccessible: api.InternetAccessible{
        InternetMaxBandwidthOut: 5,
        InternetChargeType:      api.TrafficPostpaidByHour,
    },
    // 使用 uuid 生成一个长度不超过64位的ASCII字符串
    ClientToken: "random-uuid",
	// 创建实例支持幂等的token,成功后永久有效
    RequestToken: "requestToken",
}
result, err := client.CreateInstanceV3(args)
if err != nil {
    fmt.Println("create instance failed:", err)
} else {
    fmt.Println("create instance success: ", result)
}

createInstanceArgs := &CreateInstanceArgs{
    // 输入你要创建instance使用的镜像ID
    ImageId:          "your-choose-image-id",
    // BCC实例类型
    InstanceType: "InstanceType"
    // BCC核数
    CpuCount: CpuCount
    // BCC的内存大小GB
    MemoryCapacityInGB: MemoryCapacityInGB
    // 系统盘大小GB
	RootDiskSizeInGb      int              "rootDiskSizeInGb"
	// 设置待查询的竞价实例的系统盘介质
    RootDiskStorageType   StorageType      "rootDiskStorageType"
	// 临时盘数据盘大小
    EphemeralDisks        []EphemeralDisk  "ephemeralDisks"
	// 创建需要创建的CDS磁盘列表
    CreateCdsList         []CreateCdsModel "createCdsList"
	// 设置创建BCC使用的网络带宽大小
    NetWorkCapacityInMbps int              networkCapacityInMbps
	// 设置需要创建BCC使用的DCC服务器id
    DedicateHostId        string           "dedicatedHostId"
	// 设置待查询的竞价实例的购买个数
    PurchaseCount         int              purchaseCount
	// 实例名称
    Name                  string           "name"
    // 实例主机名,可选参数,若不选则主机名和实例名称保持一致(实例名称不包含中文名时)
    // 仅支持小写字母、数字以及- . 特殊字符，不可连续使用特殊符号，不支持特殊符号开头或结尾，长度2-64
    Hostname:        "your-choose-instance-hostname",
    // 设置是否自动生成hostname和name有序后缀 是:true 否:false
    AutoSeqSuffix:        false,
    // 设置是否开启hostname domain 是：true 否：false
    IsOpenHostnameDomain:   false,
	// 设置BCC虚机密码
    AdminPass             string           "adminPass"
	// 设置可用区
    ZoneName              string           "zoneName"
	// 指定子网和安全组创建，要求子网和安全组必须同时指定或同时不指定，
    // 同时指定的子网和安全组必须同属于一个VPC，都不指定会使用默认子网和默认安全组。
    // 设置创建BCC使用的子网
    SubnetId              string           "subnetId"
	// // 设置创建BCC使用的安全组
    SecurityGroupId       string           "securityGroupId"
	// 设置需要创建GPU卡信息
    GpuCard               string           "gpuCard"
	// 设置需要创建FPGA卡信息
    FpgaCard              string           "fpgaCard"
	// 设置GPU卡或FPGA卡数量
    CardCount             string           "cardCount"
	// 设置按月付费或者按年付费 月是"month",年是"year"
    AutoRenewTimeUnit     string           "autoRenewTimeUnit"
	// 设置自动续费的时间 按月是1-9 按年是 1-3
    AutoRenewTime         int              autoRenewTime
	// cds是否自动续费 是:true 否:false
    CdsAutoRenew          bool             cdsAutoRenew
	// 待创建实例指定的标签是否需要和已有标签键进行关联，默认为false。注意值为true时要保证该标签键已存在
    RelationTag           bool             relationTag
	// 待创建的标签列表
    Tags                  []model.TagModel tags
	// 指定实例所在的部署集id
    DeployId              string           "deployId"
	// 设置创建BCC虚机使用的竞价模式：market 或者 custom
    BidModel              string           "bidModel"
	// 设置创建BCC虚机使用的竞价金额,只有当bidModel为custom时有效
    BidPrice              string           "bidPrice"
	// 设置要绑定的密钥对ID
    KeypairId             string           "keypairId"
	// 设置要绑定的自动快照策略ID
    AspId                 string           "aspId"
	// 公网带宽计费方式，若不指定internetChargeType，默认付费方式同BCC，预付费默认为包年包月按带宽，后付费默认为按使用带宽计费。（BANDWIDTH_PREPAID：预付费按带宽结算；TRAFFIC_POSTPAID_BY_HOUR：流量按小时后付费；BANDWIDTH_POSTPAID_BY_HOUR：带宽按小时后付费）
    InternetChargeType    string           "internetChargeType"
    // 设置内网IP
    InternalIps           []string         internalIps
    // 设置创建BCC虚机使用的竞价模式：market 或者 custom
    BidModel              string           "bidModel"
	// 设置创建BCC虚机使用的竞价金额,只有当bidModel为custom时有效
    BidPrice              string           "bidPrice"
	// 使用 uuid 生成一个长度不超过64位的ASCII字符串
    ClientToken           string           "random-uuid"
    // 创建实例支持幂等的token,成功后永久有效
    RequestToken          string           "requestToken"
}
if res, err := bccClient.CreateBidInstance(createInstanceBySpecArgs); err != nil {
    fmt.Println("create instance failed: ", err)
} else {
    fmt.Println("create instance success, instanceId: ", res.InstanceIds[0])
}

cancelBidOrderRequest := &CancelBidOrderRequest{
    // 订单ID
    OrderId     string "orderId"
}
if err := bccClient.CancelBidOrder(cancelBidOrderRequest); err != nil {
    fmt.Println("CancelBidOrderRequest failed: ", err)
} else {
    fmt.Println("CancelBidOrderRequest success.")
}

if res, err := bccClient.ListBidFlavor(); err != nil {
    fmt.Println("List bidding instance flavors failed: ", err)
} else {
    fmt.Println("List bidding instance flavors success, result: ", res)
}

createCdsList := []api.CreateCdsModel{{
    // 设置CDS磁盘容量，必须为大于0的整数，单位为GB，大小为0~5120G，可选参数
    CdsSizeInGB: 40,
    // 设置CDS磁盘存储类别，默认为高性能型，可选参数
    StorageType: api.StorageTypeHP1,
    // 设置快照ID
    SnapshotId:  "your-snapshot-id",
    // 设置加密密钥，true或false
    EncryptKey:  true,
}}
tagList := []model.TagModel{{
    // 设置要查询的tagKey
    TagKey:   "your-tag-key",
    // 设置要查询的tagValue
    TagValue: "your-tag-value",
}}
args := &api.GetBidInstancePriceArgs{
    // 使用 uuid 生成一个长度不超过64位的ASCII字符串
    ClientToken:           "random-uuid",
     // 设置待查询的虚拟机实例类型，具体可选类型参见InstanceType
    InstanceType:          "your-choose-instance-type",
    // 设置待查询虚拟机实例的CPU核数
    CpuCount:              1,
    // 设置待查询虚拟机实例的内存容量
    MemoryCapacityInGB:    2,
    // 设置待查询虚拟机实例的系统盘大小，单位GB，默认是40GB，范围为[40, 100]GB，超过40GB按照云磁盘价格收费。注意指定的系统盘大小需要满足所使用镜像最小磁盘空间限制。
    RootDiskSizeInGb:      45,
    // 设置待查询虚拟机实例系统盘介质，默认使用SSD型云磁盘，可指定系统盘磁盘类型可参见StorageType
    RootDiskStorageType:   api.StorageTypeCloudHP1,
    // 设置待查询的CDS磁盘列表
    CreateCdsList:           createCdsList,
    // 设置批量查询（购买）的虚拟机实例个数，必须为大于0的整数，可选参数，缺省为1
    PurchaseCount:         1,
    // 设置虚拟机名字，可选参数
    Name:                  "your-choose-instance-name",
    // 设置实例管理员密码(8-16位字符，英文，数字和符号必须同时存在，符号仅限!@#$%^*()),可选参数
    AdminPass:             "your-admin-pass",
    // 设置待查询实例所要绑定的密钥对ID,可选参数
    KeypairId:             "your-keypair-id",
    // 设置自动快照策略ID,可选参数
    AspId:                 "your-asp-id",
    // 设置待查询虚拟机实例的镜像ID,可选参数
    ImageId:               "your-image-id",
    // 设置竞价实例出价模型， 市场价: "market" 自定义："custom",可选参数
    BidModel:              "your-bid-model",
    // 设置竞价实例出价金额，若是自定义出价，且出价金额小于市场价，则不允许创建。当bidModel='custom'时才有效,可选参数
    BidPrice:              "your-bid-price",
    // 设置公网带宽，单位为Mbps。必须为0~200之间的整数，为0表示不分配公网IP，默认为0Mbps,可选参数
    NetWorkCapacityInMbps: 20,
    // 设置待查询实例指定的标签是否需要和已有标签键进行关联，默认为false。注意值为true时要保证该标签键已存在,可选参数
    RelationTag:           false,
    // 设置待查询的标签列表,可选参数
    Tags:                    tagList,
    // 设置securityGroup信息，为空时将使用默认安全组,可选参数
    SecurityGroupId:       "your-security-group-id",
    // 设置subnet信息，为空时将使用默认子网,可选参数
    SubnetId:              "your-subnet-id",
    // 设置指定zone信息，默认为空，由系统自动选择,可选参数
    ZoneName:              "your-zone-name",
    // 设置公网带宽计费方式,可选参数
    InternetChargeType:    "your-internet-charge-type",
}
if res, err := bccClient.GetBidInstancePrice(args); err != nil {
    fmt.Println("Get bidding instance price failed: ", err)
} else {
    fmt.Println("Get bidding instance price success, result: ", res)
}

// 实例类型
instanceType := "instanceType"
// CPU核数
cpuCount := cpuCount
// 内存容量（GB）
memoryCapacityInGB := memoryCapacityInGB
// 可用区名称
zoneName := "zoneNamen"
// GPU卡类型，GPU和VGPU可填
gpuCard := "gpuCard"
// GPU卡数量，GPU和VGPU可填
cardCount := "cardCount"
//本地盘信息
ephemeralDisks := []EphemeralDisks{{
      "storageType": "ssd",
      "sizeInGB": sizeInGB,
}}

args := &api.CreateInstanceStockArgs{
    InstanceType:     instanceType,
    CpuCount: cpuCount,
    MemoryCapacityInGB:  memoryCapacityInGB,
    ZoneName:  zoneName,
    GpuCard:  gpuCard,
    CardCount:  cardCount,
    EphemeralDisks:  ephemeralDisks,
}
if res, err := bccClient.GetInstanceCreateStock(args); err != nil {
    fmt.Println("GetInstanceCreateStock failed: ", err)
} else {
    fmt.Println("GetInstanceCreateStock success: ", res)
}

// 实例id
instanceId := "instanceId"
// CPU核数
cpuCount := cpuCount
// 内存容量（GB）
memoryCapacityInGB := memoryCapacityInGB

args := &api.CreateInstanceStockArgs{
    InstanceId:     instanceId,
    CpuCount: cpuCount,
    MemoryCapacityInGB:  memoryCapacityInGB,
}
if res, err := bccClient.ResizeInstanceStockArgs(args); err != nil {
    fmt.Println("ResizeInstanceStockArgs failed: ", err)
} else {
    fmt.Println("ResizeInstanceStockArgs success: ", res)
}

// 设置你要操作的instanceId
instanceId := "your-choose-instance-id"
//设置是否展示部署集字段,true or false
isDeploySet := "your-isDeploySet"

if res, err := bccClient.GetInstanceDetailWithDeploySet(instanceId,isDeploySet); err != nil {
fmt.Println("get instance detail failed: ", err)
} else {
fmt.Println("get instance detail success, result: ", res)
}

// 设置你要操作的instanceId
instanceId := "your-choose-instance-id"
//设置是否展示部署集字段,true or false
isDeploySet := "your-isDeploySet"
//设置是否展示部署集字段,true or false
containsFailed := "your-containsFailed"

if res, err := bccClient.GetInstanceDetailWithDeploySet(instanceId,isDeploySet,containsFailed); err != nil {
fmt.Println("get instance detail failed: ", err)
} else {
fmt.Println("get instance detail success, result: ", res)
}

// 设置你要查询的deploySetID
deploySetID := "your-choose-deploy-set-id"
if res, err := bccClient.GetDeploySet(deploySetID); err != nil {
    fmt.Println("Delete deploy set failed: ", err)
} else {
    fmt.Println("Get deploy set success: ", res)
}

listInstanceArgs := &ListInstanceArgs{
    // 批量获取列表的查询起始位置，是一个由系统产生的字符串
    Marker          string
	// 设置返回数据大小，缺省为1000
    MaxKeys         int
	// 通过internal Ip过滤
    InternalIp      string
	// 通过DedicatedHostId过滤
    DedicatedHostId string
	// 通过ZoneName过滤
    ZoneName        string
	// 通过KeypairId过滤
    KeypairId       string
}

if res, err := bccClient.GetInstanceNoChargeList(listInstanceArgs); err != nil {
    fmt.Println("GetInstanceNoChargeList failed: ", err)
} else {
    fmt.Println("GetInstanceNoChargeList success, result: ", res)
}

args := &api.ListInstanceArgs{}

// 若要查询某个内网IP对应的实例列表，可以配置以下参数
args.InternalIp = "1.1.1.1"

result, err := client.ListInstances(args)
if err != nil {
    fmt.Println("list instance failed:", err)
} else {
    fmt.Println("list instance success: ", result)
}

args := &api.ListServerRequestV3Args{
Marker:      "",
MaxKeys:     3,
}
result, err := BCC_CLIENT.ListServersByMarkerV3(args)
if err != nil {
fmt.Println("list instance failed: ", err)
} else {
fmt.Println("list instance  success")
data, e := json.Marshal(result)
if e != nil {
fmt.Println("json marshal failed!")
return
}
fmt.Printf("list instance : %s", data)
}

// 批量获取列表的查询的起始位置，是一个由系统生成的字符串,可选参数
marker := "your-marker"
// 每页包含的最大数量，最大数量通常不超过1000。缺省值为1000,可选参数
maxKeys := your-maxKeys
// 设置想要查询的付费类型,可选参数 Prepaid表示预付费，Postpaid表示后付费，不传表示都选
paymentTiming := "Postpaid"
// 设置想要查询的虚机id,可选参数
instanceId := "your-choose-instance-id"
// 设置想要查询的虚机名称,可选参数
name := "your-choose-name"
// 设置想要查询虚机的回收开始时间(北京时间),可选参数 （闭区间）
recycleBegin := "2020-11-19T09:12:35Z"
// 设置想要查询虚机的回收结束时间(北京时间),可选参数 （开区间）
recycleEnd := "2020-11-26T09:12:35Z"
args := &api.ListRecycleInstanceArgs{
    Marker:         marker,
    MaxKeys:        maxKeys,
    PaymentTiming:  paymentTiming,
    InstanceId:     instanceId,
    Name:           name,
    RecycleBegin:   recycleBegin,
    RecycleEnd:     recycleEnd, 
}
result, err := client.ListRecycleInstances(args)
if err != nil {
    fmt.Println("list instance failed:", err)
} else {
    fmt.Println("list instance success: ", result)
}

// 设置你要操作的instanceId
instanceId := "your-choose-instance-id"

result, err := client.GetInstanceDetail(instanceId)
if err != nil {
    fmt.Println("get instance detail failed:", err)
} else 
    fmt.Println("get instance detail success ", result)
}

err := client.StartInstance(instanceId)
if err != nil {
    fmt.Println("start instance failed:", err)
} else {
    fmt.Println("start instance success")
}

// 以下代码可以强制停止一个实例
err := client.StopInstance(instanceId, true)
if err != nil {
    fmt.Println("stop instance failed:", err)
} else {
    fmt.Println("stop instance success")
}

// 设置你要操作的instanceId
instanceId := "your-choose-instance-id"
// 设置是否强制停止，强制停止等同于断电处理，可能丢失实例操作系统中未写入磁盘的数据
forceStop ：= false
// 设置是否关机不计费，TRUE为关机不计费，FALSE为关机计费。注意：只有白名单用户才可以实行关机不计费
stopWithNoCharge := false

if err := bccClient.StopInstanceWithNoCharge(instanceId, forceStop, stopWithNoCharge); err != nil {
    fmt.Println("Stop instance failed: ", err)
} else {
    fmt.Println("Stop instance success.")
}

// 以下代码可以强制重启一个实例
err := client.RebootInstance(instanceId, true)
if err != nil {
    fmt.Println("reboot instance failed:", err)
} else {
    fmt.Println("reboot instance success")
}

// 设置你要操作的instanceId
instanceId := "your-choose-instance-id"
args := &api.ChangeInstancePassArgs{
	AdminPass: "321zaq#@!",
}
err := client.ChangeInstancePass(instanceId, args)
if err != nil {
    fmt.Println("change instance password failed:", err)
} else {
    fmt.Println("change instance password success")
}

// 设置你要操作的instanceId
instanceId := "your-choose-instance-id"
args := &api.ModifyInstanceAttributeArgs{
    Name: "newInstanceName",
}
err := client.ModifyInstanceAttribute(instanceId, args)
if err != nil {
    fmt.Println("modify instance failed:", err)
} else {
    fmt.Println("modify instance success")
}

// 设置你要操作的instanceId
instanceId := "your-choose-instance-id"
args := &api.ModifyInstanceDescArgs{
    Description: "new Instance description",
}
err := client.ModifyInstanceDesc(instanceId, args)
if err != nil {
    fmt.Println("modify instance failed:", err)
} else {
    fmt.Println("modify instance success")
}

// 设置你要操作的instanceId
instanceId := "your-choose-instance-id"
args := &api.ModifyInstanceHostnameArgs{
    // 设置想要修改的新主机名
    Hostname:               "new Instance hostname",
    // 设置是否开启domain，可选参数 true表示开启 false和null 表示关闭
    IsOpenHostnameDomain:   true,
    // 设置是否自动重启，可选参数 true表示重启，false和null表示不重启
    Reboot:                 true,
}
err := client.ModifyInstanceHostname(instanceId, args)
if err != nil {
    fmt.Println("modify instance hostname failed:", err)
} else {
    fmt.Println("modify instance hostname success")
}

args := &api.RebuildInstanceArgs{
	ImageId:   "m-DpgNg8lO",
	AdminPass: "123qaz!@#",
	// 设置要绑定的密钥对ID
    KeypairId string "keypairId"
}
err := client.RebuildInstance(instanceId, args)
if err != nil {
    fmt.Println("rebuild instance failed:", err)
} else {
    fmt.Println("rebuild instance success")
}

rebuildBatchInstanceArgs := &RebuildBatchInstanceArgs{
    // 输入你要重装instance使用的镜像ID
    ImageId   string "imageId"
	// 设置BCC虚机密码
    AdminPass string "adminPass"
	// 设置要绑定的密钥对ID
    KeypairId string "keypairId"
    // 实例ID集合
    InstanceIds []string "instanceIds"
}

if err := bccClient.BatchRebuildInstances(rebuildBatchInstanceArgs); err != nil {
    fmt.Println("rebuild instance failed: ", err)
} else {
    fmt.Println("rebuild instance success.")
}

err := client.DeleteInstance(instanceId)
if err != nil {
    fmt.Println("delete instance failed:", err)
} else {
    fmt.Println("delete instance success")
}

deleteInstanceWithRelateResourceArgs := &DeleteInstanceWithRelateResourceArgs{
    // 设置释放的时候是否关联释放当前时刻，实例挂载的eip+数据盘 false代表否 true代表是
    // (只有该字段为true时 deleteCdsSnapshotFlag字段才会有效，若该字段为false,deleteCdsSnapshotFlag字段的值无效）
    RelatedReleaseFlag    bool "relatedReleaseFlag"
    //设置是否释放弹性网卡 false代表否 true代表是，默认false
    DeleteRelatedEnisFlag bool "deleteRelatedEnisFlag"
	// 设置是否释放云磁盘快照 false代表否 true代表是
    DeleteCdsSnapshotFlag bool "deleteCdsSnapshotFlag"
    // 设置是否进入回收站 true表示进入回收站， false和null表示不进入回收站
    BccRecycleFlag        bool "bccRecycleFlag"
}
// 设置你要操作的instanceId
instanceId := "your-choose-instance-id"

if err := bccClient.DeleteInstanceWithRelateResource(instanceId, deleteInstanceWithRelateResourceArgs); err != nil {
    fmt.Println("release instance failed: ", err)
} else {
    fmt.Println("release instance success.")
}

deleteInstanceWithRelateResourceArgs := &BatchDeleteInstanceWithRelateResourceArgs{
    // 设置释放的时候是否关联释放当前时刻，实例挂载的eip+数据盘 false代表否 true代表是
    // (只有该字段为true时 deleteCdsSnapshotFlag字段才会有效，若该字段为false,deleteCdsSnapshotFlag字段的值无效）
    RelatedReleaseFlag    bool "relatedReleaseFlag"
    //设置是否释放弹性网卡 false代表否 true代表是，默认false
    DeleteRelatedEnisFlag bool "deleteRelatedEnisFlag"
	// 设置是否释放云磁盘快照 false代表否 true代表是
    DeleteCdsSnapshotFlag bool "deleteCdsSnapshotFlag"
    // 设置是否进入回收站 true表示进入回收站， false和null表示不进入回收站
    BccRecycleFlag        bool "bccRecycleFlag"
    // 批量释放的实例id
    InstanceIds           []string "instanceIds"
}
if err := bccClient.BatchDeleteInstanceWithRelateResource(deleteInstanceWithRelateResourceArgs); err != nil {
    fmt.Println("release instance failed: ", err)
} else {
    fmt.Println("release instance success.")
}

	args := &api.DeleteInstanceIngorePaymentArgs{
		InstanceId:      "instanceid",
		//设置是否释放eip和cds false代表eip和cds与实例解绑，实例进回收站；true代表eip解绑，cds与实例绑定进回收站
		RelatedReleaseFlag: true,
		//设置是否释放弹性网卡 false代表否 true代表是，默认false
		DeleteRelatedEnisFlag:true,
		//设置是否释放云磁盘快照 false代表否 true代表是，默认false，释放预付费bcc时DeleteCdsSnapshotFlag和RelatedReleaseFlag存在绑定关系，
        RelatedReleaseFlag为true时，DeleteCdsSnapshotFlag必须为true
		// 选择DeleteCdsSnapshotFlag=true即会释放虚机绑定的各种快照
		// 释放后付费bcc时，DeleteCdsSnapshotFlag和RelatedReleaseFlag之间逻辑和之前逻辑保持一致
		DeleteCdsSnapshotFlag:true,
        //设置是否立即释放，默认false，保持释放进入回收站逻辑；为true时，实例和设置了关联释放的cds资源，一起立即释放
        DeleteImmediate: false,

	}
	if res, err := BCC_CLIENT.DeleteInstanceIngorePayment(args); err != nil {
		fmt.Println("delete  instance failed: ", err)
	} else {
		fmt.Printf("delete  instance success, result: %s", res.String())
	}

// 设置你要操作的instanceId
instanceId := "your-choose-instance-id"
if err := bccClient.DeleteRecycledInstance(instanceId); err != nil {
    fmt.Println("release instance failed: ", err)
} else {
    fmt.Println("release instance success.")
}

err := bccClient.AutoReleaseInstance(instanceId, "2021-05-01T07:58:09Z")
if err != nil {
    fmt.Println("set instance autoRelease failed:", err)
} else {
    fmt.Println("set instance autoRelease success")
}

args := &api.DeletionProtectionArgs {
// 释放保护状态 0不启用，1启用
    DeletionProtection : 0,
}
// 设置你要操作的instanceId
instanceId := "your-choose-instance-id"

if err := bccClient.ModifyDeletionProtection(instanceId, args); err != nil {
    fmt.Println("modifyDeletionProtection failed: ", err)
} else {
    fmt.Println("modifyDeletionProtection success.")
}

resizeInstanceArgs := &ResizeInstanceArgs{
    // BCC核数
    CpuCount: CpuCount
    // BCC的内存大小GB
    MemoryCapacityInGB: MemoryCapacityInGB
	// 临时盘数据盘大小
    EphemeralDisks        []EphemeralDisk  "ephemeralDisks"
}
// 设置你要操作的instanceId
instanceId := "your-choose-instance-id"

if err := bccClient.ResizeInstance(instanceId, resizeInstanceArgs); err != nil {
    fmt.Println("resize instance failed: ", err)
} else {
    fmt.Println("resize instance success.")
}

resizeInstanceArgs := &ResizeInstanceArgs{
    // 实例套餐规格
    Spec               string          "spec"
}
// 设置你要操作的instanceId
instanceId := "your-choose-instance-id"

if err := bccClient.ResizeInstanceBySpec(instanceId, resizeInstanceArgs); err != nil {
    fmt.Println("resize instance failed: ", err)
} else {
    fmt.Println("resize instance success.")
}

// 设置你要操作的instanceId
instanceId := "your-choose-instance-id"
// 设置BCC绑定的安全组
SecurityGroupId := "SecurityGroupId"

if err := bccClient.BindSecurityGroup(instanceId, SecurityGroupId); err != nil {
    fmt.Println("Bind Security Group failed: ", err)
} else {
    fmt.Println("Bind Security Group success.")
}

// 设置你要操作的instanceId
instanceId := "your-choose-instance-id"
// 设置BCC解绑的安全组
SecurityGroupId := "SecurityGroupId"

if err := bccClient.UnBindSecurityGroup(instanceId, SecurityGroupId); err != nil {
    fmt.Println("UnBind Security Group failed: ", err)
} else {
    fmt.Println("UnBind Security Group success.")
}

args := &api.ResizeInstanceArgs{
	CpuCount:           2,
	MemoryCapacityInGB: 4,
	LiveResize:      true,
}
err := client.ResizeInstance(instanceId, args)
if err != nil {
    fmt.Println("resize instance failed:", err)
} else {
    fmt.Println("resize instance success")

result, err := client.GetInstanceVNC(instanceId)
if err != nil {
    fmt.Println("get instance VNC url failed:", err)
} else {
    fmt.Println("get instance VNC url success: ", result)
}

args := &api.PurchaseReservedArgs{
    Billing: &api.Billing{
        PaymentTiming: api.PaymentTimingPrePaid,
        Reservation: &api.Reservation{
            ReservationLength:   1,
            ReservationTimeUnit: "month",
        }
    }
}
// 设置你要操作的instanceId
instanceId := "your-choose-instance-id"
// 设置实例关联续费标识，默认为空字符串。
relatedRenewFlag := "CDS"

if err := bccClient.InstancePurchaseReserved(instanceId, ModifyInstanceDescArgs); err != nil {
    fmt.Println("Modify Instance Attribute failed: ", err)
} else {
    fmt.Println("Modify Instance Attribute success.")
}

args := &api.InstanceChangeSubnetArgs{
	InstanceId: instanceId,
	SubnetId:   subnetId,
	InternalIp: internalIp,
	Reboot:     false,
}
err := client.InstanceChangeSubnet(args)
if err != nil {
    fmt.Println("change instance subnet failed:", err)
} else {
    fmt.Println("change instance subnet success")
}

args := &api.InstanceChangeVpcArgs{
    InstanceId: instanceId,
    SubnetId: subnetId, 
    InternalIp: internalIp,
    Reboot: true,
    SecurityGroupIds: securityGroupId,
    EnterpriseSecurityGroupIds: enterpriseSecurityGroupId
}
err := client.InstanceChangeVpc(args)
if err != nil {
    fmt.Println("change instance vpc failed:", err)
} else {
    fmt.Println("change instance vpc success")
}

batchAddIpArgs := &BatchAddIpArgs{
    // 实例ID
    InstanceId string "instanceId"
    // 辅助IP，和SecondaryPrivateIpAddressCount不可同时使用
	PrivateIps []string "privateIps"
    // 自动分配IP数量，和PrivateIps不可同时使用
    SecondaryPrivateIpAddressCount int 1
    // 幂等性Token，使用 uuid 生成一个长度不超过64位的ASCII字符串，可选参数
    ClietnToken string "clientToken"
}

if res, err := bccClient.BatchAddIP(batchAddIpArgs); err != nil {
    fmt.Println("BatchAddIP failed: ", err)
} else {
    fmt.Println("BatchAddIP success, result: ", res)
}

privateIps := []string{"192.168.1.25"}
instanceId := "your-choose-instance-id"
// 幂等性Token，使用 uuid 生成一个长度不超过64位的ASCII字符串，可选参数
clientToken := "clientToken"
batchDelIpArgs := &api.BatchDelIpArgs{
	InstanceId:     instanceId,
	PrivateIps:     privateIps,
    ClientToken:    clientToken,
}
if err := client.BatchDelIP(batchDelIpArgs); err != nil {
    fmt.Println("delete ips failed: ", err)
} else {
    fmt.Println("delete ips success.")
}

bccCreateAutoRenewArgs := &api.BccCreateAutoRenewArgs{
    // 实例ID
    InstanceId: instanceId,
    // 续费单位，month，year
    RenewTimeUnit: "month",
    // 续费时长，单位：month，支持1, 2, 3, 4, 5, 6, 7, 8, 9；单位：year，支持1, 2, 3
    RenewTime: 1,
}

if err := bccClient.BatchCreateAutoRenewRules(bccCreateAutoRenewArgs); err != nil {
    fmt.Println("BatchCreateAutoRenewRules failed: ", err)
} else {
    fmt.Println("BatchCreateAutoRenewRules success.")
}

bccDeleteAutoRenewArgs := &api.BccDeleteAutoRenewArgs{
	// 实例ID
	InstanceId: instanceId,
}

if err := bccClient.BatchDeleteAutoRenewRules(bccDeleteAutoRenewArgs); err != nil {
    fmt.Println("BatchDeleteAutoRenewRules failed: ", err)
} else {
    fmt.Println("BatchDeleteAutoRenewRules success.")
}

args := &api.RecoveryInstanceArgs{
    InstanceIds: []api.RecoveryInstanceModel{
        {
            InstanceId: instanceId,
        },
    },
}
if err := BCC_CLIENT.RecoveryInstance(args); err != nil {
    fmt.Println("recovery instance failed: ", err)
} else {
    fmt.Println("recovery instance success")
}
		

changeToPrepaidRequest := &ChangeToPrepaidRequest{
    // 设置将要变更预付费的时长，单位为月
    Duration    int  "duration"
	// 设置是否变更关联的数据盘，TRUE表示变更，FLASE表示不变更
    RelationCds bool "relationCds"
}
// 设置你要操作的instanceId
instanceId := "your-choose-instance-id"

if err := bccClient.ChangeToPrepaid(instanceId, changeToPrepaidRequest); err != nil {
    fmt.Println("ChangeToPrepaid failed: ", err)
} else {
    fmt.Println("ChangeToPrepaid success.")
}

bindTagsRequest := &BindTagsRequest{
    // 设置想要绑定的标签
    ChangeTags: []model.TagModel{
        {
            TagKey:   "TagKey",
            TagValue: "TagValue",
        },
    },
}
// 设置你要操作的instanceId
instanceId := "your-choose-instance-id"

if err := bccClient.BindInstanceToTags(instanceId, bindTagsRequest); err != nil {
    fmt.Println("BindInstanceToTags failed: ", err)
} else {
    fmt.Println("BindInstanceToTags success.")
}

unBindTagsRequest := &UnBindTagsRequest{
    // 设置想要解绑的标签
    ChangeTags: []model.TagModel{
        {
            TagKey:   "TagKey",
            TagValue: "TagValue",
        },
    },
}
// 设置你要操作的instanceId
instanceId := "your-choose-instance-id"

if err := bccClient.UnBindInstanceToTags(instanceId, unBindTagsRequest); err != nil {
    fmt.Println("UnBindInstanceToTags failed: ", err)
} else {
    fmt.Println("UnBindInstanceToTags success.")
}

 listAvailableResizeSpecsArgs := &api.ListAvailableResizeSpecsArgs{
     Spec: "bcc.ic5.c1m1",
     Zone: "cn-bj-a",
 }
 res, _ := BCC_CLIENT.ListAvailableResizeSpecs(listAvailableResizeSpecsArgs)
 fmt.Println(res)

 batchChangeInstanceToPrepayArgs := &api.BatchChangeInstanceToPrepayArgs{
     Config: []api.PrepayConfig{
         {
             InstanceId:  BCC_TestBccId,
             Duration:    1,
             RelationCds: false,
         },
     },
 }
 result, _ := BCC_CLIENT.BatchChangeInstanceToPrepay(batchChangeInstanceToPrepayArgs)
 fmt.Println(result)

 batchChangeInstanceToPostArgs := &api.BatchChangeInstanceToPostpayArgs{
     Config: []api.PostpayConfig{
         {
             InstanceId:  "i-43TqYnnq",
             RelationCds: false,
         },
     },
 }
 result, _ := BCC_CLIENT.BatchChangeInstanceToPostpay(batchChangeInstanceToPostArgs)
 fmt.Println(result)

 res, _ := BCC_CLIENT.ListInstanceRoles()
 fmt.Println(res)

 bindInstanceRoleArgs := &api.BindInstanceRoleArgs{
     RoleName: "Test_BCC",
     Instances: []api.Instances{
         {
             InstanceId: BCC_TestBccId,
         },
     },
 }

 result, _ := BCC_CLIENT.BindInstanceRole(bindInstanceRoleArgs)
 fmt.Println(result)

	unbindInstanceRoleArgs := &api.UnBindInstanceRoleArgs{
		RoleName: "Test_BCC",
		Instances: []api.Instances{
			{
				InstanceId: BCC_TestBccId,
			},
		},
	}

	result, _ := BCC_CLIENT.UnBindInstanceRole(unbindInstanceRoleArgs)
	ExpectEqual(t.Errorf, err, nil)
	fmt.Println(result)

 addIpv6Args := &api.AddIpv6Args{
     InstanceId:  BCC_TestBccId,
     Reboot:      true,
     Ipv6Address: "2400:da00:e003:0:41c:4100:0:2",
 }

 result, _ := BCC_CLIENT.AddIpv6(addIpv6Args)
 ExpectEqual(t.Errorf, err, nil)
 fmt.Println(result)

deleteIpv6Args := &api.DeleteIpv6Args{
     InstanceId: BCC_TestBccId,
     Reboot:     true,
 }

 err := BCC_CLIENT.DeleteIpv6(deleteIpv6Args)
 fmt.Println(err)

args := &api.ListInstanceByInstanceIdArgs{}
result, err := BCC_CLIENT.ListInstanceByInstanceIds(args)
if err != nil {
    fmt.Println("list instance failed:", err)
} else {
    fmt.Println("list instance success: ", result)
}

 bccId := "bccId"
 args := &api.GetInstanceDeleteProgressArgs{
     InstanceIds: []string{
         bccId,
     },
 }

 res, err := BCC_CLIENT.GetInstanceDeleteProgress(args)
 if err != nil {
    fmt.Println(err)
 }
 fmt.Println(res)

// 设置你要操作的instanceId
instanceId := "instanceId"
if res, err := BCC_CLIENT.ListInstanceEnis(instanceId); err != nil {
	fmt.Println("Get specific instance eni failed: ", err)
} else {
	fmt.Println("Get specific instance eni success, result: ", res)
}