Initialization

Confirm Endpoint

Before configuring the Endpoint for SDK usage, please refer to the developer guide section on BCC Access Domains to understand Endpoint-related concepts. Baidu AI Cloud currently supports multiple regions. Please refer to Region Selection Guide.

Retrieve access key

To utilize BCC, you are required to have a valid AK (Access Key ID) and SK (Secret Access Key) for signature authentication. AK/SK are system-provided identifiers used to recognize users and carry out signature validation for BCC.

Your AK/SK information can be obtained and understood through the following steps:

Register a Baidu AI Cloud account

Create AK/SK

Create a new BCC client

The BCC client acts as the interface for BCC services, providing developers with various methods to engage with BCC service functionalities.

Create a new BCC client with AK/SK

Users can refer to the following code to create a new BCC client to access BCC with AK/SK:

1import (
2	"github.com/baidubce/bce-sdk-go/services/bcc"
3)
4func main() {
5 // User’s Access Key ID and Secret Access Key
6	AK, SK := <your-access-key-id>, <your-secret-access-key>
7 // User-specified Endpoint
8	ENDPOINT := <domain-name>
9 // Initialize a BCCClient
10	bccClient, err := bcc.NewClient(AK, SK, ENDPOINT)
11}

In the code above, AK corresponds to the "Access Key ID" in the console, and SK corresponds to the "Access Key Secret" in the console. For the access method, please refer to the Operation Guide for Managing Access Key. The third parameter ENDPOINT is a user-specified domain name. If left empty, the default domain name will be used as the BCC service address.

Note:The endpoint parameter must be defined with the domain name of the specified region. For example, if the service is located in Beijing, the endpoint will be bcc.bj.baidubce.com.

Create a BCC client with STS

Request STS Token

BCC facilitates temporary third-party access authorization using the STS mechanism. STS (Security Token Service) is a Baidu AI Cloud feature that allows you to issue access credentials with flexible validity periods and specific permissions for third-party users. These users can use the credentials to directly invoke Baidu AI Cloud APIs or SDKs to access cloud resources.

To access BCC via STS, users must first request an certification string through the STS client. For instructions on obtaining STS credentials, refer to Baidu AI Cloud STS Usage Guide.

Create BCC Client with STS Token

Once the STS token has been obtained, it should be set up in the BCC Client to enable STS-based client creation.

Code example

The GO SDK implements the STS service API. Below is a complete example for requesting an STS Token and creating an BCC Client object:

1import (
2	"fmt"
3 "github.com/baidubce/bce-sdk-go/auth"                    //Import the authentication module
4 "github.com/baidubce/bce-sdk-go/services/bcc" //Import BCC service module
5 "github.com/baidubce/bce-sdk-go/services/sts"            //Import the Baige service module
6)
7func main() {
8 //Create a Client object for the STS service, using the default Endpoint
9	AK, SK := <your-access-key-id>, <your-secret-access-key>
10	stsClient, err := sts.NewClient(AK, SK)
11	if err != nil {
12		fmt.Println("create sts client object :", err)
13		return
14	}
15 //Obtain a temporary authentication token with a validity period of 60 seconds and an empty ACL
16	stsObj, err := stsClient.GetSessionToken(60, "")
17	if err != nil {
18		fmt.Println("get session token failed:", err)
19		return
20    }
21	fmt.Println("GetSessionToken result:")
22	fmt.Println("  accessKeyId:", stsObj.AccessKeyId)
23	fmt.Println("  secretAccessKey:", stsObj.SecretAccessKey)
24	fmt.Println("  sessionToken:", stsObj.SessionToken)
25	fmt.Println("  createTime:", stsObj.CreateTime)
26	fmt.Println("  expiration:", stsObj.Expiration)
27	fmt.Println("  userId:", stsObj.UserId)
28 //Create a BCC Client object using the requested temporary STS, with the default endpoint
29	bccClient, err := bcc.NewClient(stsObj.AccessKeyId, stsObj.SecretAccessKey, "")
30	if err != nil {
31		fmt.Println("create bcc client failed:", err)
32		return
33	}
34	stsCredential, err := auth.NewSessionBceCredentials(
35		stsObj.AccessKeyId,
36		stsObj.SecretAccessKey,
37		stsObj.SessionToken)
38	if err != nil {
39		fmt.Println("create sts credential object failed:", err)
40		return
41	}
42	bccClient.Config.Credentials = stsCredential
43}

Note: Currently, when configuring a BCC client with STS, regardless of where the corresponding BCC service endpoint is located, the STS endpoint must be set to http://sts.bj.baidubce.com. This default is utilized when creating an STS object in the above code.

Configure HTTPS access to BCC

BCC supports the HTTPS transport protocol. You can specify HTTPS in the Endpoint when creating the BCC Client object to access Baige service using HTTPS in the BCC GO SDK:

1// import "github.com/baidubce/bce-sdk-go/services/bcc"
2 ENDPOINT := ""https://bcc.bj.baidubce.com" // Specify the use of HTTPS protocol
3AK, SK := <your-access-key-id>, <your-secret-access-key>
4bccClient, _ := bcc.NewClient(AK, SK, ENDPOINT)

Configure the BCC client

If users need to configure specific parameters for the BCC Client, they can customize the configuration using the exported Config field of the BCC Client object after its creation. This allows for configuring parameters such as proxy and maximum number of connections for the client.

Use a proxy

The following code snippet enables the client to access BCC service using a proxy:

1// import "github.com/baidubce/bce-sdk-go/services/bcc"
2 // Create an BCC Client object
3AK, SK := <your-access-key-id>, <your-secret-access-key>
4ENDPOINT := "bcc.bj.baidubce.com"
5client, _ := bcc.NewClient(AK, SK, ENDPOINT)
6 // Use the local port 8080 for the proxy
7client.Config.ProxyUrl = "127.0.0.1:8080"

Set network parameters

Users can configure network parameters using the following example code:

1// import "github.com/baidubce/bce-sdk-go/services/bcc"
2AK, SK := <your-access-key-id>, <your-secret-access-key>
3ENDPOINT := "bcc.bj.baidubce.com"
4client, _ := bcc.NewClient(AK, SK, ENDPOINT)
5 // Configure to not retry, default: Back Off retry
6client.Config.Retry = bce.NewNoRetryPolicy()
7 // Configure connection timeout to 30 seconds
8client.Config.ConnectionTimeoutInMillis = 30 * 1000

Configure options for generating signature strings

1// import "github.com/baidubce/bce-sdk-go/services/bcc"
2AK, SK := <your-access-key-id>, <your-secret-access-key>
3ENDPOINT := "bcc.bj.baidubce.com"
4client, _ := bcc.NewClient(AK, SK, ENDPOINT)
5 // Configure the HTTP request header Host for signing
6headersToSign := map[string]struct{}{"Host": struct{}{}}
7client.Config.SignOption.HeadersToSign = HeadersToSign
8 // Configure the validity period of the signature to 30 seconds
9client.Config.SignOption.ExpireSeconds = 30

Parameter description

When using the GO SDK to access BCC, the Config field of the created BCC Client object supports the following parameters, as shown in the table below:

Description:

1. The Credentials field is created using the auth.NewBceCredentials and auth.NewSessionBceCredentials functions. The former is used by default, while the latter is used for STS certification. See "Create a BCC client with STS" for details.
2. The SignOption field represents options when generating a signature string, as detailed in the table below:

1 Among configuration options, HeadersToSign defaults to `Host`, `Content-Type`, `Content-Length` and `Content-MD5`; TimeStamp is typically set to zero, indicating that the timestamp at the time of generating the certification string shall be used, and users generally shall not explicitly specify the value for this field; ExpireSeconds defaults to 1,800 seconds or 30 minutes.

3. The Retry field specifies the retry policy, currently supporting two types: NoRetryPolicy and BackOffRetryPolicy. By default, the latter is used. This retry policy specifies the maximum number of retries, the maximum retry duration, and the retry base. Retries increase exponentially based on the retry base multiplied by 2 until the maximum number of retries or the maximum retry duration is reached.