1// import "github.com/baidubce/bce-sdk-go/services/rds"
2
3args := &rds.CreateRdsArgs{
4	// 指定rds的数据库引擎，取值mysql，sqlserver，postgresql，必选
5    Engine:            "mysql",
6    // 指定rds的数据库版本，必选
7    EngineVersion:  "5.6",
8    // 计费相关参数，PaymentTiming取值为 预付费：Prepaid，后付费：Postpaid；Reservation：支付方式为后支付时不需要设置，预支付时必须设置；必选
9    Billing: rds.Billing{
10        PaymentTiming: "Postpaid",
11        //Reservation: rds.Reservation{ReservationLength: 1, ReservationTimeUnit: "Month"},
12    },
13    // 预付费时可指定自动续费参数 AutoRenewTime 和 AutoRenewTimeUnit
14    // 自动续费时长（续费单位为year 不大于3，续费单位为month 不大于9）
15    // AutoRenewTime: 1,
16    // 自动续费单位（"year";"month"）
17    // AutoRenewTimeUnit: "year",
18    // CPU核数，必选
19    CpuCount: 1,
20    //套餐内存大小，单位GB，必选
21    MemoryCapacity: 1,
22    //套餐磁盘大小，单位GB，每5G递增，必选
23    VolumeCapacity: 5,
24    //磁盘类型, normal_io:本地盘ssd磁盘, cloud_high:高性能云磁盘, cloud_nor:通用型SSD, cloud_enha:增强型SSD, 必选
25    DiskIoType: "normal_io",
26    //批量创建云数据库 RDS 实例个数, 最大不超过10，默认1，可选
27    PurchaseCount: 1,
28    //rds实例名称，允许小写字母、数字，长度限制为1~32，默认命名规则:{engine} + {engineVersion}，可选
29    InstanceName: "instanceName",
30    //所属系列，Basic：单机基础版，Standard：双机高可用版。仅SQLServer 2012sp3 支持单机基础版。默认Standard，可选
31    Category: "Standard",
32    //指定zone信息，默认为空，由系统自动选择，可选
33    //zoneName命名规范是小写的“国家-region-可用区序列"，例如北京可用区A为"cn-bj-a"。
34    ZoneNames: []string{"cn-bj-d"},
35    //vpc，如果不提供则属于默认vpc，可选
36    VpcId: "vpc-IyrqYIQ7",
37    //是否进行直接支付，默认false，设置为直接支付的变配订单会直接扣款，不需要再走支付逻辑，可选
38    IsDirectPay: false,
39    //vpc内，每个可用区的subnetId；如果不是默认vpc则必须指定 subnetId，可选
40    Subnets: []rds.SubnetMap{
41        {
42            ZoneName: "cn-bj-a",
43            SubnetId: "sbn-IyWRnII7",
44        },   
45    },
46    // 实例绑定的标签信息，可选
47    Tags: []model.TagModel{
48        {
49            TagKey:   "tagK",
50            TagValue: "tagV",
51        },
52    },
53}
54result, err := client.CreateRds(args)
55if err != nil {
56    fmt.Printf("create rds error: %+v\n", err)
57    return
58}
59
60for _, e := range result.InstanceIds {
61	fmt.Println("create rds success, instanceId: ", e)
62}

1// import "github.com/baidubce/bce-sdk-go/services/rds"
2
3args := &rds.CreateReadReplicaArgs{
4    //主实例ID，必选
5    SourceInstanceId: "sourceInstanceId"
6    // 计费相关参数，PaymentTiming取值为 预付费：Prepaid，后付费：Postpaid；Reservation：支付方式为后支付时不需要设置，预支付时必须设置；必选
7    Billing: rds.Billing{
8        PaymentTiming: "Postpaid",
9    },
10    // CPU核数，必选
11    CpuCount: 1,
12    //套餐内存大小，单位GB，必选
13    MemoryCapacity: 1,
14    //套餐磁盘大小，单位GB，每5G递增，必选
15    VolumeCapacity: 5,
16    //批量创建云数据库 RDS 只读实例个数, 可选
17    PurchaseCount: 1,
18    //实例名称，允许小写字母、数字，长度限制为1~32，默认命名规则:{engine} + {engineVersion}，可选
19    InstanceName: "instanceName",
20    //指定zone信息，默认为空，由系统自动选择，可选
21    //zoneName命名规范是小写的“国家-region-可用区序列"，例如北京可用区A为"cn-bj-a"。
22    ZoneNames: []string{"cn-bj-d"},
23    //与主实例 vpcId 相同，可选
24    VpcId: "vpc-IyrqYIQ7",
25    //是否进行直接支付，默认false，设置为直接支付的变配订单会直接扣款，不需要再走支付逻辑，可选
26    IsDirectPay: false,
27    //vpc内，每个可用区的subnetId；如果不是默认vpc则必须指定 subnetId，可选
28    Subnets: []rds.SubnetMap{
29        {
30            ZoneName: "cn-bj-a",
31            SubnetId: "sbn-IyWRnII7",
32        },   
33    },
34    // 实例绑定的标签信息，可选
35    Tags: []model.TagModel{
36        {
37            TagKey:   "tagK",
38            TagValue: "tagV",
39        },
40    },
41}
42result, err := client.CreateReadReplica(args)
43if err != nil {
44    fmt.Printf("create rds readReplica error: %+v\n", err)
45    return
46}
47
48for _, e := range result.InstanceIds {
49	fmt.Println("create rds readReplica success, instanceId: ", e)
50}

1// import "github.com/baidubce/bce-sdk-go/services/rds"
2
3args := &rds.CreateRdsProxyArgs{
4    //主实例ID，必选
5    SourceInstanceId: "sourceInstanceId"
6    // 计费相关参数，代理实例只支持后付费Postpaid，必选
7    Billing: rds.Billing{
8        PaymentTiming: "Postpaid",
9    },
10    // 代理实例节点数。取值范围2，4，6，8，16，必选
11    NodeAmount: 2,
12    //实例名称，允许小写字母、数字，长度限制为1~32，默认命名规则:{engine} + {engineVersion}，可选
13    InstanceName: "instanceName",
14    //指定zone信息，默认为空，由系统自动选择，可选
15    //zoneName命名规范是小写的“国家-region-可用区序列"，例如北京可用区A为"cn-bj-a"，建议与主实例的可用区保持一致
16    ZoneNames: []string{"cn-bj-d"},
17    //与主实例 vpcId 相同，可选
18    VpcId: "vpc-IyrqYIQ7",
19    //是否进行直接支付，默认false，设置为直接支付的变配订单会直接扣款，不需要再走支付逻辑，可选
20    IsDirectPay: false,
21    //vpc内，每个可用区的subnetId；如果不是默认vpc则必须指定 subnetId，可选
22    Subnets: []rds.SubnetMap{
23        {
24            ZoneName: "cn-bj-a",
25            SubnetId: "sbn-IyWRnII7",
26        },   
27    },
28    // 实例绑定的标签信息，可选
29    Tags: []model.TagModel{
30        {
31            TagKey:   "tagK",
32            TagValue: "tagV",
33        },
34    },
35}
36result, err := client.CreateRdsProxy(args)
37if err != nil {
38    fmt.Printf("create rds proxy error: %+v\n", err)
39    return
40}
41
42for _, e := range result.InstanceIds {
43	fmt.Println("create rds proxy success, instanceId: ", e)
44}

1// import "github.com/baidubce/bce-sdk-go/services/rds"
2
3args := &rds.ListRdsArgs{
4    // 批量获取列表的查询的起始位置，是一个由系统生成的字符串，可选
5    Marker: "marker",
6    // 指定每页包含的最大数量(主实例)，最大数量不超过1000，缺省值为1000，可选
7    MaxKeys: 1,
8}
9result, err := client.ListRds(args)
10if err != nil {
11    fmt.Printf("list rds error: %+v\n", err)
12    return
13}
14
15// 返回标记查询的起始位置
16fmt.Println("rds list marker: ", result.Marker)
17// true表示后面还有数据，false表示已经是最后一页
18fmt.Println("rds list isTruncated: ", result.IsTruncated)
19// 获取下一页所需要传递的marker值。当isTruncated为false时，该域不出现
20fmt.Println("rds list nextMarker: ", result.NextMarker)
21// 每页包含的最大数量
22fmt.Println("rds list maxKeys: ", result.MaxKeys)
23// 获取rds的列表信息
24for _, e := range result.Instances {
25    fmt.Println("rds instanceId: ", e.InstanceId)
26    fmt.Println("rds instanceName: ", e.InstanceName)
27    fmt.Println("rds engine: ", e.Engine)
28    fmt.Println("rds engineVersion: ", e.EngineVersion)
29    fmt.Println("rds instanceStatus: ", e.InstanceStatus)
30    fmt.Println("rds cpuCount: ", e.CpuCount)
31    fmt.Println("rds memoryCapacity: ", e.MemoryCapacity)
32    fmt.Println("rds volumeCapacity: ", e.VolumeCapacity)
33    fmt.Println("rds usedStorage: ", e.UsedStorage)
34    fmt.Println("rds paymentTiming: ", e.PaymentTiming)
35    fmt.Println("rds instanceType: ", e.InstanceType)
36    fmt.Println("rds instanceCreateTime: ", e.InstanceCreateTime)
37    fmt.Println("rds instanceExpireTime: ", e.InstanceExpireTime)
38    fmt.Println("rds publicAccessStatus: ", e.PublicAccessStatus)
39    fmt.Println("rds task: ", e.Task)
40    fmt.Println("rds vpcId: ", e.VpcId)
41}

1// import "github.com/baidubce/bce-sdk-go/services/rds"
2
3result, err := client.GetDetail(instanceId)
4if err != nil {
5    fmt.Printf("get rds detail error: %+v\n", err)
6    return
7}
8
9fmt.Println("rds instanceId: ", result.InstanceId)
10fmt.Println("rds instanceName: ", result.InstanceName)
11fmt.Println("rds engine: ", result.Engine)
12fmt.Println("rds engineVersion: ", result.EngineVersion)
13fmt.Println("rds instanceStatus: ", result.InstanceStatus)
14fmt.Println("rds cpuCount: ", result.CpuCount)
15fmt.Println("rds memoryCapacity: ", result.MemoryCapacity)
16fmt.Println("rds volumeCapacity: ", result.VolumeCapacity)
17fmt.Println("rds usedStorage: ", result.UsedStorage)
18fmt.Println("rds paymentTiming: ", result.PaymentTiming)
19fmt.Println("rds instanceType: ", result.InstanceType)
20fmt.Println("rds instanceCreateTime: ", result.InstanceCreateTime)
21fmt.Println("rds instanceExpireTime: ", result.InstanceExpireTime)
22fmt.Println("rds publicAccessStatus: ", result.PublicAccessStatus)
23fmt.Println("rds vpcId: ", result.VpcId)

1// import "github.com/baidubce/bce-sdk-go/services/rds"
2
3//多个实例间用英文半角逗号","隔开，最多可输入10个
4if err := client.DeleteRds(instanceIds); err != nil {
5    fmt.Printf("delete rds error: %+v\n", err)
6    return
7}
8fmt.Printf("delete rds success\n")

1// import "github.com/baidubce/bce-sdk-go/services/rds"
2
3args := &rds.ResizeRdsArgs{
4	// cpu核数
5    CpuCount: 2,
6    // 内存大小，单位GB
7    MemoryCapacity: 8,
8    // 磁盘大小，单位GB，每5G递增
9    VolumeCapacity: 20,
10    // 代理实例节点数，代理实例变配时此项必填
11    NodeAmount: 2,
12    // 是否进行直接支付，默认false，设置为直接支付的变配订单会直接扣款，不需要再走支付逻辑，可选
13    IsDirectPay: false,
14}
15err = client.ResizeRds(instanceId, args)
16if err != nil {
17    fmt.Printf("resize rds error: %+v\n", err)
18    return
19}
20
21fmt.Println("resize rds success.")

1// import "github.com/baidubce/bce-sdk-go/services/rds"
2
3err := client.RebootInstance(instanceId)
4if err != nil {
5    fmt.Printf("reboot rds error: %+v\n", err)
6    return
7}

1// import "github.com/baidubce/bce-sdk-go/services/rds"
2
3args := &rds.UpdateInstanceNameArgs{
4    InstanceName: "instanceName",
5}
6err = client.UpdateInstanceName(instanceId, args)
7if err != nil {
8    fmt.Printf("update instance name error: %+v\n", err)
9    return
10}
11fmt.Printf("update instance name success\n")

1// import "github.com/baidubce/bce-sdk-go/services/rds"
2
3args := &rds.AutoRenewArgs{
4    // 自动续费时长（续费单位为year 不大于3，续费单位为month 不大于9）必选
5	AutoRenewTime: 1,
6    // 自动续费单位（"year";"month"）必选
7	AutoRenewTimeUnit: "year",
8    // 实例id集合 必选
9    InstanceIds: []string{
10        "rds-y9dJu77d", 
11        "rds-aQFOoncr",
12    },
13}
14err := client.AutoRenew(args)
15if err != nil {
16    fmt.Printf("create auto renew error: %+v\n", err)
17    return
18}

1// import "github.com/baidubce/bce-sdk-go/services/rds"
2
3args := &rds.ModifySyncModeArgs{
4    //"Async"异步复制，"Semi_sync"半同步复制。
5    SyncMode: "Async",
6}
7err = client.ModifySyncMode(instanceId, args)
8if err != nil {
9    fmt.Printf("modify syncMode error: %+v\n", err)
10    return
11}
12fmt.Printf("modify syncMode success\n")

1// import "github.com/baidubce/bce-sdk-go/services/rds"
2
3args := &rds.ModifyEndpointArgs{
4    Address: "newAddress",
5}
6err = client.ModifyEndpoint(instanceId, args)
7if err != nil {
8    fmt.Printf("modify endpoint error: %+v\n", err)
9    return
10}
11fmt.Printf("modify endpoint success\n")

1// import "github.com/baidubce/bce-sdk-go/services/rds"
2
3args := &rds.ModifyPublicAccessArgs{
4    // true or false
5    PublicAccess: true,
6}
7err = client.ModifyPublicAccess(instanceId, args)
8if err != nil {
9    fmt.Printf("modify public access error: %+v\n", err)
10    return
11}
12fmt.Printf("modify public access success\n")

1// import "github.com/baidubce/bce-sdk-go/services/rds"
2
3args := &rds.MaintainTimeArgs{
4    MaintainStartTime: "14:00:00",
5    MaintainDuration:  2,
6}
7err = client.UpdateMaintainTime(instanceId, args)
8if err != nil {
9    fmt.Printf("update maintain time error: %+v\n", err)
10    return
11}
12fmt.Printf("update maintain time success\n")

1// import "github.com/baidubce/bce-sdk-go/services/rds"
2
3args := &rds.DiskAutoResizeArgs{
4    FreeSpaceThreshold: 10,
5    DiskMaxLimit:       2000,
6}
7err = client.ConfigDiskAutoResize(instanceId,"open", args)
8if err != nil {
9    fmt.Printf("config disk auto resize error: %+v\n", err)
10    return
11}
12fmt.Printf("config disk auto resize success\n")

1// import "github.com/baidubce/bce-sdk-go/services/rds"
2
3result, err = client.GetAutoResizeConfig(instanceId)
4if err != nil {
5    fmt.Printf("get config error: %+v\n", err)
6    return
7}
8fmt.Printf("get config success\n")

1// import "github.com/baidubce/bce-sdk-go/services/rds"
2
3result, err = client.EnableAutoExpansion(instanceId)
4if err != nil {
5    fmt.Printf("get enable auto expansion error: %+v\n", err)
6    return
7}
8fmt.Printf("get enable auto expansion success\n")

1// import "github.com/baidubce/bce-sdk-go/services/rds"
2args := &rds.AzoneMigration{
3    MasterAzone: "cn-bj-d",
4    BackupAzone: "cn-bj-e",
5    ZoneNames:   []string{"cn-bj-d", "cn-bj-e"},
6    Subnets: []SubnetMap{
7        {
8            ZoneName: "cn-bj-d",
9            SubnetId: "sbn-nedt51qre6r2",
10        },
11        {
12            ZoneName: "cn-bj-e",
13            SubnetId: "sbn-hc20wss3idai",
14        },
15    },
16    EffectiveTime: "timewindow",
17}
18result, err = client.AzoneMigration(instanceId, args)
19if err != nil {
20    fmt.Printf("azone migration error: %+v\n", err)
21    return
22}
23fmt.Printf("azone migration success\n")