import (
	"github.com/baidubce/bce-sdk-go/services/rds"
)

func main() {
	// users' Access Key ID and Secret Access Key
	ACCESS_KEY_ID, SECRET_ACCESS_KEY := <your-access-key-id>, <your-secret-access-key>

	// Endpoint specified by users
	ENDPOINT := <domain-name>

	// initialize an RDSClient
	rdsClient, err := rds.NewClient(AK, SK, ENDPOINT)
}

import (
	"fmt"

	"github.com/baidubce/bce-sdk-go/auth"         //load authentication module
	"github.com/baidubce/bce-sdk-go/services/rds" //load RDS service module
	"github.com/baidubce/bce-sdk-go/services/sts" //load STS service module
)

func main() {
	// create the Client object of STS service, Engpoint takes the default value
	AK, SK := <your-access-key-id>, <your-secret-access-key>
	stsClient, err := sts.NewClient(AK, SK)
	if err != nil {
		fmt.Println("create sts client object :", err)
		return
	}

	// obtain temporary authentication token, valid for 60 seconds, ACL is empty
	stsObj, err := stsClient.GetSessionToken(60, "")
	if err != nil {
		fmt.Println("get session token failed:", err)
		return
    }
	fmt.Println("GetSessionToken result:")
	fmt.Println("  accessKeyId:", stsObj.AccessKeyId)
	fmt.Println("  secretAccessKey:", stsObj.SecretAccessKey)
	fmt.Println("  sessionToken:", stsObj.SessionToken)
	fmt.Println("  createTime:", stsObj.CreateTime)
	fmt.Println("  expiration:", stsObj.Expiration)
	fmt.Println("  userId:", stsObj.UserId)

	// create Client object of RDS service using temporary STS applied for, Endpoint takes the default value
	rdsClient, err := rds.NewClient(stsObj.AccessKeyId, stsObj.SecretAccessKey, "")
	if err != nil {
		fmt.Println("create rds client failed:", err)
		return
	}
	stsCredential, err := auth.NewSessionBceCredentials(
		stsObj.AccessKeyId,
		stsObj.SecretAccessKey,
		stsObj.SessionToken)
	if err != nil {
		fmt.Println("create sts credential object failed:", err)
		return
	}
	rdsClient.Config.Credentials = stsCredential
}

// import "github.com/baidubce/bce-sdk-go/services/rds"

ENDPOINT := "https://rds.bj.baidubce.com" //specify the use of HTTPS protocol
AK, SK := <your-access-key-id>, <your-secret-access-key>
rdsClient, _ := rds.NewClient(AK, SK, ENDPOINT)

// import "github.com/baidubce/bce-sdk-go/services/rds"

//Create RDS Client object
AK, SK := <your-access-key-id>, <your-secret-access-key>
ENDPOINT := "rds.bj.baidubce.com"
client, _ := rds.NewClient(AK, SK, ENDPOINT)

//the proxy uses the local 8080 port
client.Config.ProxyUrl = "127.0.0.1:8080"

// import "github.com/baidubce/bce-sdk-go/services/rds"

AK, SK := <your-access-key-id>, <your-secret-access-key>
ENDPOINT := "rds.bj.baidubce.com"
client, _ := rds.NewClient(AK, SK, ENDPOINT)

// configuration does not support rtry, Back Off retry by default
client.Config.Retry = bce.NewNoRetryPolicy()

// time-out period of configuration connection is 30s
client.Config.ConnectionTimeoutInMillis = 30 * 1000

// import "github.com/baidubce/bce-sdk-go/services/rds"

AK, SK := <your-access-key-id>, <your-secret-access-key>
ENDPOINT := "rds.bj.baidubce.com"
client, _ := rds.NewClient(AK, SK, ENDPOINT)

// the request header of HTTP used in configuration signature is `Host`
headersToSign := map[string]struct{}{"Host": struct{}{}}
client.Config.SignOption.HeadersToSign = HeadersToSign

// the validity of configuration signature is 30s
client.Config.SignOption.ExpireSeconds = 30

1. the `credentials' field is created with the functions `auth.newbcauthentications' and auth.NewSessionBceCredentials'. the former is used by default, while the latter is used when STS is used for authentication. See the subsection "creating RDS Client with STS" for details.
2. 2. the ``SignOption` field is an option when a signature string is generated, detailed in the following table:

 In which, HeadersToSign defaults to `Host`，`Content-Type`，`Content-Length`，`Content-MD5`；TimeStamp is 0 generally, representing the timestamp when the authentication string generated is called and used, and the value of the field is not clearly specified by user generally; ExpireSeconds defaults to be 1800 seconds, that is, 30min. 

3. The retry policy is specified in `retry' field, which currently supports two types: `NoRetryPolicy`和`BackOffRetryPolicy`。The latter is used by default. The retry policy is to specify the maximum number of retries, the longest retry time and the retry base, and to retry according to the exponential growth of the retry base multiplied by 2 until the maximum retry test or the longest retry time is reached.