Configure access credentials - Object Storage Service - Alibaba Cloud Documentation Center

To use Object Storage Service (OSS) SDK for Go to initiate a request, you must configure access credentials. Alibaba Cloud services use access credentials to verify your identity information and access permissions. You can select different types of access credentials based on the requirements for authentication and authorization. This topic describes how to configure temporary access credentials and long-term access credentials.

Prerequisites

OSS SDK for Go is installed. For more information, see Installation.

Access credentials

You can choose from the following types of access credentials:

Temporary access credentials: For scenarios that require high security, such as temporary access authorization of applications to access OSS, we recommend that you use temporary access credentials. Temporary access credentials have a validity period for access. This helps prevent access credentials from being leaked. Temporary access credentials support fine-grained access control to prevent security risks caused by excessive permissions. For more information, see Use temporary access credentials.
Long-term access credentials: To ensure security, we recommend that you do not use long-term access credentials. For scenarios that require convenience, long-term access credentials can prevent multiple refreshes in a long period of time. We recommend that you change your long-term access credentials every three months to ensure the security of your Alibaba Cloud account. When long-term access credentials are leaked or no longer used, you can delete or disable the long-term access credentials to prevent security risks. For more information, see Use long-term access credentials.

Use temporary access credentials

If you want to use OSS SDK for Go to temporarily access OSS resources, you can use one of the following methods to configure temporary access credentials:

Configure Security Token Service (STS) temporary access credentials: If you want to access OSS within a specific period of time, you can use STS to obtain temporary access credentials. The temporary access credentials provided by STS do not disclose the AccessKey pair of your RAM user. This ensures that your access to OSS resources is secure.
Configure a RAM role: If you want to grant a RAM user of your Alibaba Cloud account or a RAM user of another Alibaba Cloud account the permissions to access OSS resources, you can configure a RAM role for the RAM user.
Configure a RAM role for an Elastic Compute Service (ECS) instance: If you want to access OSS resources from an ECS instance, you can use a RAM role of the ECS instance to access OSS resources. You can attach a RAM role to an ECS instance to access OSS resources from the instance by using temporary credentials that are obtained from STS. STS temporary access credentials are automatically generated and updated. Applications can obtain STS temporary access credentials by using the instance metadata URL.

Configure STS temporary access credentials

Create a RAM user.
For more information, see Create a RAM user.
Attach the AliyunSTSAssumeRoleAccess policy to the RAM user.
For more information, see Grant permissions to RAM users.
Use the RAM user to call the AssumeRole operation of STS to obtain temporary access credentials.
For more information, see AssumeRole.

Configure the temporary access credentials provided by STS.

Environment variables

Use the temporary access credentials provided by STS to configure environment variables.

macOS

Open the terminal.
Run the following command:
```
nano ~/.bash_profile
```

Add the temporary access credentials (AccessKeyId, AccessKeySecret, and SecurityToken) obtained from STS to the end of the file.

export OSS_ACCESS_KEY_ID=STS.NV5ZCwphFSXqscqUHAKbH****
export OSS_ACCESS_KEY_SECRET=IrVTNZNy5yQelTETg0cZML3TQn**** 
export OSS_SESSION_TOKEN=CAES+wMIARKAAZhjH0EUOIhJMQBMjRywXq7MQ/cjLYg80Aho1ek0Jm63XMhr9Oc5s˙∂˙∂3qaPer8p1YaX1NTDiCFZWFkvlHf1pQhuxfKBc+mRR9KAbHUefqH+rdjZqjTF7p2m1wJXP8S6k+G2MpHrUe6TYBkJ43GhhTVFMuM3BZajY3VjZWOXBIODRIR1FKZjIiEjMzMzE0MjY0NzM5MTE4NjkxMSoLY2xpZGSSDgSDGAGESGTETqOio6c2RrLWRlbW8vKgoUYWNzOm9zczoqOio6c2RrLWRlbW9KEDExNDg5MzAxMDcyNDY4MThSBTI2ODQyWg9Bc3N1bWVkUm9sZVVzZXJgAGoSMzMzMTQyNjQ3MzkxMTg2OTExcglzZGstZGVt****

Press Ctrl + X, press Y to save the file, and then press Enter to close the file.
Run the following command for the changes to take effect:
```
source ~/.bash_profile
```

Run the following command to verify the configurations of the environment variables:

echo $OSS_ACCESS_KEY_ID
echo $OSS_ACCESS_KEY_SECRET
echo $OSS_SESSION_TOKEN

Sample success response:

STS.NV5ZCwphFSXqscqUHAKbH****
IrVTNZNy5yQelTETg0cZML3TQn**** 
CAES+wMIARKAAZhjH0EUOIhJMQBMjRywXq7MQ/cjLYg80Aho1ek0Jm63XMhr9Oc5s˙∂˙∂3qaPer8p1YaX1NTDiCFZWFkvlHf1pQhuxfKBc+mRR9KAbHUefqH+rdjZqjTF7p2m1wJXP8S6k+G2MpHrUe6TYBkJ43GhhTVFMuM3BZajY3VjZWOXBIODRIR1FKZjIiEjMzMzE0MjY0NzM5MTE4NjkxMSoLY2xpZGSSDgSDGAGESGTETqOio6c2RrLWRlbW8vKgoUYWNzOm9zczoqOio6c2RrLWRlbW9KEDExNDg5MzAxMDcyNDY4MThSBTI2ODQyWg9Bc3N1bWVkUm9sZVVzZXJgAGoSMzMzMTQyNjQ3MzkxMTg2OTExcglzZGstZGVt****

Linux

Open the terminal.
Run the following command:
```
sudo vim /etc/profile
```

Add the temporary access credentials (AccessKeyId, AccessKeySecret, and SecurityToken) obtained from STS to the end of the file.

export OSS_ACCESS_KEY_ID=STS.NV5ZCwphFSXqscqUHAKbH****
export OSS_ACCESS_KEY_SECRET=IrVTNZNy5yQelTETg0cZML3TQn****
export OSS_SESSION_TOKEN=CAES+wMIARKAAZhjH0EUOIhJMQBMjRywXq7MQ/cjLYg80Aho1ek0Jm63XMhr9Oc5s˙∂˙∂3qaPer8p1YaX1NTDiCFZWFkvlHf1pQhuxfKBc+mRR9KAbHUefqH+rdjZqjTF7p2m1wJXP8S6k+G2MpHrUe6TYBkJ43GhhTVFMuM3BZajY3VjZWOXBIODRIR1FKZjIiEjMzMzE0MjY0NzM5MTE4NjkxMSoLY2xpZGSSDgSDGAGESGTETqOio6c2RrLWRlbW8vKgoUYWNzOm9zczoqOio6c2RrLWRlbW9KEDExNDg5MzAxMDcyNDY4MThSBTI2ODQyWg9Bc3N1bWVkUm9sZVVzZXJgAGoSMzMzMTQyNjQ3MzkxMTg2OTExcglzZGstZGVt****

Press Esc to exit the edit mode. Then, enter :wq and press Enter to save and close the file.
Run the following command for the changes to take effect:
```
source /etc/profile
```

Run the following command to verify the configurations of the environment variables:

echo $OSS_ACCESS_KEY_ID
echo $OSS_ACCESS_KEY_SECRET
echo $OSS_SESSION_TOKEN

Sample success response:

STS.NV5ZCwphFSXqscqUHAKbH****
IrVTNZNy5yQelTETg0cZML3TQn**** 
CAES+wMIARKAAZhjH0EUOIhJMQBMjRywXq7MQ/cjLYg80Aho1ek0Jm63XMhr9Oc5s˙∂˙∂3qaPer8p1YaX1NTDiCFZWFkvlHf1pQhuxfKBc+mRR9KAbHUefqH+rdjZqjTF7p2m1wJXP8S6k+G2MpHrUe6TYBkJ43GhhTVFMuM3BZajY3VjZWOXBIODRIR1FKZjIiEjMzMzE0MjY0NzM5MTE4NjkxMSoLY2xpZGSSDgSDGAGESGTETqOio6c2RrLWRlbW8vKgoUYWNzOm9zczoqOio6c2RrLWRlbW9KEDExNDg5MzAxMDcyNDY4MThSBTI2ODQyWg9Bc3N1bWVkUm9sZVVzZXJgAGoSMzMzMTQyNjQ3MzkxMTg2OTExcglzZGstZGVt****

Windows

Open the command-line interface (CLI).

Run the following command to configure the temporary access credentials (AccessKeyId, AccessKeySecret, and SecurityToken) obtained from STS:

set OSS_ACCESS_KEY_ID=STS.NV5ZCwphFSXqscqUHAKbH****
set OSS_ACCESS_KEY_SECRET=IrVTNZNy5yQelTETg0cZML3TQn****
set OSS_SESSION_TOKEN=CAES+wMIARKAAZhjH0EUOIhJMQBMjRywXq7MQ/cjLYg80Aho1ek0Jm63XMhr9Oc5s˙∂˙∂3qaPer8p1YaX1NTDiCFZWFkvlHf1pQhuxfKBc+mRR9KAbHUefqH+rdjZqjTF7p2m1wJXP8S6k+G2MpHrUe6TYBkJ43GhhTVFMuM3BZajY3VjZWOXBIODRIR1FKZjIiEjMzMzE0MjY0NzM5MTE4NjkxMSoLY2xpZGSSDgSDGAGESGTETqOio6c2RrLWRlbW8vKgoUYWNzOm9zczoqOio6c2RrLWRlbW9KEDExNDg5MzAxMDcyNDY4MThSBTI2ODQyWg9Bc3N1bWVkUm9sZVVzZXJgAGoSMzMzMTQyNjQ3MzkxMTg2OTExcglzZGstZGVt****

Run the following command for the changes to take effect:

setx OSS_ACCESS_KEY_ID "%OSS_ACCESS_KEY_ID%"
setx OSS_ACCESS_KEY_SECRET "%OSS_ACCESS_KEY_SECRET%"
setx OSS_SESSION_TOKEN "%OSS_SESSION_TOKEN%"

Run the following command to verify the configurations of the environment variables:

echo %OSS_ACCESS_KEY_ID%
echo %OSS_ACCESS_KEY_SECRET%
echo %OSS_SESSION_TOKEN%

Sample success response:

STS.NV5ZCwphFSXqscqUHAKbH****
IrVTNZNy5yQelTETg0cZML3TQn**** 
CAES+wMIARKAAZhjH0EUOIhJMQBMjRywXq7MQ/cjLYg80Aho1ek0Jm63XMhr9Oc5s˙∂˙∂3qaPer8p1YaX1NTDiCFZWFkvlHf1pQhuxfKBc+mRR9KAbHUefqH+rdjZqjTF7p2m1wJXP8S6k+G2MpHrUe6TYBkJ43GhhTVFMuM3BZajY3VjZWOXBIODRIR1FKZjIiEjMzMzE0MjY0NzM5MTE4NjkxMSoLY2xpZGSSDgSDGAGESGTETqOio6c2RrLWRlbW8vKgoUYWNzOm9zczoqOio6c2RrLWRlbW9KEDExNDg5MzAxMDcyNDY4MThSBTI2ODQyWg9Bc3N1bWVkUm9sZVVzZXJgAGoSMzMzMTQyNjQ3MzkxMTg2OTExcglzZGstZGVt****

Obtain the temporary access credentials provided by STS from the environment variables.

package main

import (
	"fmt"
	"github.com/aliyun/aliyun-oss-go-sdk/oss"
	"os"
)

func main() {
	// Use the temporary AccessKey pair and security token obtained from the environment variables to configure the access credentials. 
	provider, err := oss.NewEnvironmentVariableCredentialsProvider()
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}
    
	// Create an OSSClient instance. 
	// Specify the endpoint of the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. Specify your actual endpoint. 
	client, err := oss.New("yourEndpoint", "", "", oss.SetCredentialsProvider(&provider))
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}
}

Embed access credentials in code

Warning

Security issues may occur when you embed access credentials in code. If access credentials are leaked, attackers can use the access credentials to access your OSS resources, which may cause data loss. To ensure security, we recommend that you use more secure methods, such as obtaining access credentials from environment variables.

package main

import (
    "fmt"
    "github.com/aliyun/aliyun-oss-go-sdk/oss"
    "os"
)
func main(){
    // Specify the endpoint of the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. Specify your actual endpoint. 
    // Specify the temporary AccessKey pair obtained from STS. The AccessKey pair consists of an AccessKey ID and an AccessKey secret. 
    // Specify the security token obtained from STS. 
    client, err := oss.New("yourEndpoint", "yourAccessKeyId", "yourAccessKeySecret", oss.SecurityToken("yourSecurityToken"))
    if err != nil {
        fmt.Println("Error:", err)
        os.Exit(-1)
    }
}

Configure a RAM role

Run the following command to install alibabacloud_credentials:
```
pip install alibabacloud_credentials
```
Obtain the AccessKey pair of a RAM user.
For more information, see Create an AccessKey pair.
Important
To reduce the risk that the AccessKey pair of a RAM user is leaked, we recommend that you rotate an AccessKey pair that is used for more than three months. We recommend that you disable and delete the AccessKey pair of a RAM user that is not used for a long period of time.
Obtain RamRoleArn of the destination RAM role.
Note
RamRoleArn is the Alibaba Cloud Resource Name (ARN) of the RAM role, which is the ID of the RAM role to be assumed. Format: acs:ram::$accountID:role/$roleName. $accountID: the ID of the Alibaba Cloud account. $roleName: the name of the RAM role.
For more information, see View the information about a RAM role.

Configure the AccessKey pair of the RAM user and RamRoleArn of the RAM role as the temporary access credentials.

Environment variables

Configure environment variables by using the obtained AccessKey pair of the RAM user and RamRoleArn of the RAM role.

macOS

Open the terminal.
Run the following command:
```
nano ~/.bash_profile
```

Add the AccessKey pair of the RAM user and RamRoleArn of the RAM role to the end of the file.

export OSS_ACCESS_KEY_ID=LTAI4GDty8ab9W4Y1D****
export OSS_ACCESS_KEY_SECRET=IrVTNZNy5yQelTETg0cZML3TQn****  
export OSS_STS_ROLE_ARN=acs:ram::17464958********:role/ossststest

Press Ctrl + X, press Y to save the file, and then press Enter to close the file.
Run the following command for the changes to take effect:
```
source /etc/profile
```

Run the following command to verify the configurations of the environment variables:

echo $OSS_ACCESS_KEY_ID
echo $OSS_ACCESS_KEY_SECRET
echo $OSS_STS_ROLE_ARN

Sample success response:

LTAI4GDty8ab9W4Y1D****
IrVTNZNy5yQelTETg0cZML3TQn****  
acs:ram::17464958********:role/ossststest

Linux

Open the terminal.
Run the following command:
```
sudo vim /etc/profile
```

Add the AccessKey pair of the RAM user and RamRoleArn of the RAM role to the end of the file.

export OSS_ACCESS_KEY_ID=LTAI4GDty8ab9W4Y1D****
export OSS_ACCESS_KEY_SECRET=IrVTNZNy5yQelTETg0cZML3TQn****  
export OSS_STS_ROLE_ARN=acs:ram::17464958********:role/ossststest

Press Esc to exit the edit mode. Then, enter :wq and press Enter to save and close the file.
Run the following command for the changes to take effect:
```
source /etc/profile
```

Run the following command to verify the configurations of the environment variables:

echo $OSS_ACCESS_KEY_ID
echo $OSS_ACCESS_KEY_SECRET
echo $OSS_STS_ROLE_ARN

Sample success response:

LTAI4GDty8ab9W4Y1D****
IrVTNZNy5yQelTETg0cZML3TQn****  
acs:ram::17464958********:role/ossststest

Windows

Open the CLI.

Run the following command to configure the AccessKey pair of the RAM user and RamRoleArn of the RAM role:

set OSS_ACCESS_KEY_ID=LTAI4GDty8ab9W4Y1D****
set OSS_ACCESS_KEY_SECRET=IrVTNZNy5yQelTETg0cZML3TQn****  
set OSS_STS_ROLE_ARN=acs:ram::17464958********:role/ossststest

Run the following command for the changes to take effect:

setx OSS_ACCESS_KEY_ID "%OSS_ACCESS_KEY_ID%"
setx OSS_ACCESS_KEY_SECRET "%OSS_ACCESS_KEY_SECRET%"
setx OSS_STS_ROLE_ARN "%OSS_STS_ROLE_ARN%"

Run the following command to verify the configurations of the environment variables:

echo %OSS_ACCESS_KEY_ID%
echo %OSS_ACCESS_KEY_SECRET%
echo %OSS_STS_ROLE_ARN%

Sample success response:

LTAI4GDty8ab9W4Y1D****
IrVTNZNy5yQelTETg0cZML3TQn****  
acs:ram::17464958********:role/ossststest

Obtain the AccessKey pair of the RAM user and RamRoleArn of the RAM role from the environment variables.

package main

import (
    "fmt"
    "github.com/aliyun/aliyun-oss-go-sdk/oss"
    "github.com/aliyun/credentials-go/credentials"
    "os"
)
type Credentials struct {
    AccessKeyId     string
    AccessKeySecret string
    SecurityToken string
}

type defaultCredentialsProvider struct {
    cred credentials.Credential
}

func (credentials *Credentials) GetAccessKeyID() string {
    return credentials.AccessKeyId
}

func (credentials *Credentials) GetAccessKeySecret() string {
    return credentials.AccessKeySecret
}

func (credentials *Credentials) GetSecurityToken() string {
    return credentials.SecurityToken
}

func (defBuild *defaultCredentialsProvider) GetCredentials() oss.Credentials {
    id,_ := defBuild.cred.GetAccessKeyId()
    secret,_ := defBuild.cred.GetAccessKeySecret()
    token,_ := defBuild.cred.GetSecurityToken()

    return &Credentials{
        AccessKeyId: *id,
        AccessKeySecret: *secret,
        SecurityToken: *token,
    }
}

func NewCredentialsProvider(credential credentials.Credential) defaultCredentialsProvider {
    return defaultCredentialsProvider{
        cred: credential,
    }
}

func main(){
    config := new(credentials.Config).
        // Set the type of the temporary access credentials to ram_role_arn. 
        SetType("ram_role_arn").
        // Obtain the AccessKey ID and AccessKey secret of the RAM user from the environment variables. 
        SetAccessKeyId(os.Getenv("OSS_ACCESS_KEY_ID")).        
        SetAccessKeySecret(os.Getenv("OSS_ACCESS_KEY_SECRET")).
		// Obtain the ARN of the RAM role from the environment variables. The ARN of the RAM role is the ID of the role to be assumed. Format: acs:ram::$accountID:role/$roleName. 
        SetRoleArn(os.Getenv("OSS_STS_ROLE_ARN")).
        // Specify the role session name to distinguish different tokens. 
        SetRoleSessionName("Role_Session_Name").
        // (Optional) Specify the permissions of the STS token. 
        SetPolicy("").
        // (Optional) Specify the validity period of the STS token. 
        SetRoleSessionExpiration(3600)


    arnCredential, err := credentials.NewCredential(config)
    if err != nil {
        fmt.Println("Error:", err)
        os.Exit(-1)
    }

    provider := NewCredentialsProvider(arnCredential)
    client, err := oss.New("oss-cn-hangzhou.aliyuncs.com", "", "", oss.SetCredentialsProvider(&provider))
    if err != nil {
        fmt.Println("Error:", err)
        os.Exit(-1)
    }
}

Embed access credentials in code

Warning

package main

import (
    "fmt"
    "github.com/aliyun/aliyun-oss-go-sdk/oss"
    "github.com/aliyun/credentials-go/credentials"
    "os"
)
type Credentials struct {
    AccessKeyId     string
    AccessKeySecret string
    SecurityToken string
}

type defaultCredentialsProvider struct {
    cred credentials.Credential
}

func (credentials *Credentials) GetAccessKeyID() string {
    return credentials.AccessKeyId
}

func (credentials *Credentials) GetAccessKeySecret() string {
    return credentials.AccessKeySecret
}

func (credentials *Credentials) GetSecurityToken() string {
    return credentials.SecurityToken
}

func (defBuild *defaultCredentialsProvider) GetCredentials() oss.Credentials {
    id,_ := defBuild.cred.GetAccessKeyId()
    secret,_ := defBuild.cred.GetAccessKeySecret()
    token,_ := defBuild.cred.GetSecurityToken()

    return &Credentials{
        AccessKeyId: *id,
        AccessKeySecret: *secret,
        SecurityToken: *token,
    }
}

func NewCredentialsProvider(credential credentials.Credential) defaultCredentialsProvider {
    return defaultCredentialsProvider{
        cred: credential,
    }
}

func main(){
    config := new(credentials.Config).
        // Set the type of the temporary access credentials to ram_role_arn. 
        SetType("ram_role_arn").
        // Specify the AccessKey pair of the RAM user. 
        SetAccessKeyId("AccessKeyId").        
        SetAccessKeySecret("AccessKeySecret").
        // Specify the ARN of the RAM role, which is the ID of the RAM role to be assumed. Format: acs:ram::$accountID:role/$roleName. 
        SetRoleArn("acs:ram::15069***********:role/ram-oss-test").
        // Specify the role session name to distinguish different tokens. 
        SetRoleSessionName("Role_Session_Name").
        // (Optional) Specify the permissions of the STS token. 
        SetPolicy("").
        // (Optional) Specify the validity period of the STS token. 
        SetRoleSessionExpiration(3600)


    arnCredential, err := credentials.NewCredential(config)
    if err != nil {
        fmt.Println("Error:", err)
        os.Exit(-1)
    }

    provider := NewCredentialsProvider(arnCredential)
    client, err := oss.New("oss-cn-hangzhou.aliyuncs.com", "", "", oss.SetCredentialsProvider(&provider))
    if err != nil {
        fmt.Println("Error:", err)
        os.Exit(-1)
    }
}

Configure a RAM role for an ECS instance

Run the following command to install alibabacloud_credentials:
```
go get github.com/aliyun/credentials-go/credentials
```
Attach a RAM role to an ECS instance.
For more information, see Attach an instance RAM role to an ECS instance.

Configure temporary access credentials by using the RAM role for the ECS instance.

package main

import (
    "fmt"
    "github.com/aliyun/aliyun-oss-go-sdk/oss"
    "github.com/aliyun/credentials-go/credentials"
    "os"
)
type Credentials struct {
    AccessKeyId     string
    AccessKeySecret string
    SecurityToken string
}

type CredentialsProvider struct {
    cred credentials.Credential
}

func (credentials *Credentials) GetAccessKeyID() string {
    return credentials.AccessKeyId
}

func (credentials *Credentials) GetAccessKeySecret() string {
    return credentials.AccessKeySecret
}

func (credentials *Credentials) GetSecurityToken() string {
    return credentials.SecurityToken
}

func (defBuild CredentialsProvider) GetCredentials() oss.Credentials {
    id,_ := defBuild.cred.GetAccessKeyId()
    secret,_ := defBuild.cred.GetAccessKeySecret()
    token,_ := defBuild.cred.GetSecurityToken()

    return &Credentials{
        AccessKeyId: *id,
        AccessKeySecret: *secret,
        SecurityToken: *token,
    }
}

func NewStaticCredentialsProvider(credential credentials.Credential) CredentialsProvider {
    return CredentialsProvider{
        cred: credential,
    }
}

func main(){
    config := new(credentials.Config).
        // Set the type of the temporary access credentials to ecs_ram_role. 
        SetType("ecs_ram_role").
        // (Optional) Specify the role name. If you do not specify the role name, OSS automatically generates a role name. We recommend that you specify a role name to reduce the number of requests. 
        SetRoleName("RoleName")

    ecsCredential, err := credentials.NewCredential(config)
    if err != nil {
        return
    }
    provider := NewStaticCredentialsProvider(ecsCredential)
    client, err := oss.New("oss-cn-hangzhou.aliyuncs.com", "", "", oss.SetCredentialsProvider(&provider))
    if err != nil {
        fmt.Println("Error:", err)
        os.Exit(-1)
    }
    fmt.Printf("client:%#v\n", client)

}

Use long-term access credentials

If you want to use OSS SDK for Go to access OSS resources in an application or service for a long period of time, you can perform the following steps to configure long-term access credentials.

If you want to access OSS resources for a long period of time, you can use the AccessKey pair of a RAM user to access OSS resources.

Configure the AccessKey pair of a RAM user

Obtain the AccessKey pair of a RAM user.
For more information, see Create an AccessKey pair.
Important
We recommend that you rotate the AccessKey pair of a RAM user that is used for more than three months. We recommend that you disable and delete the AccessKey pair of a RAM user that is not used for a long period of time. This reduces the risk of AccessKey pair leaks.

Configure the AccessKey pair of the RAM user.

Environment variables

Configure environment variables.
macOS
1. Open the terminal.
2. Run the following command:
```
nano ~/.bash_profile
```
3. Add the AccessKey pair of the RAM user to the end of the file.
```
export OSS_ACCESS_KEY_ID=LTAI4GDty8ab9W4Y1D****
export OSS_ACCESS_KEY_SECRET=IrVTNZNy5yQelTETg0cZML3TQn**** 
```
4. Press Ctrl + X, press Y to save the file, and then press Enter to close the file.
5. Run the following command for the changes to take effect:
```
source ~/.bash_profile
```
6. Run the following command to verify the configurations of the environment variables:
```
echo $OSS_ACCESS_KEY_ID
echo $OSS_ACCESS_KEY_SECRET
```
  Sample success response:
```
LTAI4GDty8ab9W4Y1D****
IrVTNZNy5yQelTETg0cZML3TQn**** 
```
Linux
1. Open the terminal.
2. Run the following command:
```
sudo vim /etc/profile
```
3. Add the AccessKey pair of the RAM user to the end of the file.
```
export OSS_ACCESS_KEY_ID=LTAI4GDty8ab9W4Y1D****
export OSS_ACCESS_KEY_SECRET=IrVTNZNy5yQelTETg0cZML3TQn**** 
```
4. Press Esc to exit the edit mode. Then, enter :wq and press Enter to save and close the file.
5. Run the following command for the changes to take effect:
```
source /etc/profile
```
6. Run the following command to verify the configurations of the environment variables:
```
echo $OSS_ACCESS_KEY_ID
echo $OSS_ACCESS_KEY_SECRET
```
  Sample success response:
```
LTAI4GDty8ab9W4Y1D****
IrVTNZNy5yQelTETg0cZML3TQn**** 
```
Windows
1. Open the CLI.
2. Run the following command to configure the AccessKey pair of the RAM user:
```
set OSS_ACCESS_KEY_ID=LTAI4GDty8ab9W4Y1D****
set OSS_ACCESS_KEY_SECRET=IrVTNZNy5yQelTETg0cZML3TQn**** 
```
3. Run the following command for the changes to take effect:
```
setx OSS_ACCESS_KEY_ID "%OSS_ACCESS_KEY_ID%"
setx OSS_ACCESS_KEY_SECRET "%OSS_ACCESS_KEY_SECRET%"
```
4. Run the following command to verify the configurations of the environment variables:
```
echo %OSS_ACCESS_KEY_ID%
echo %OSS_ACCESS_KEY_SECRET%
```
  Sample success response:
```
LTAI4GDty8ab9W4Y1D****
IrVTNZNy5yQelTETg0cZML3TQn**** 
```

Obtain the AccessKey pair of the RAM user from the environment variables.

package main

import (
	"fmt"
	"github.com/aliyun/aliyun-oss-go-sdk/oss"
	"os"
)

func main() {
	// Configure access credentials by using the AccessKey pair of the RAM user obtained from environment variables. 
	provider, err := oss.NewEnvironmentVariableCredentialsProvider()
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}

	// Create an OSSClient instance. 
	// Specify the endpoint of the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. Specify your actual endpoint. 
	client, err := oss.New("yourEndpoint", "", "", oss.SetCredentialsProvider(&provider))
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}
}

Embed access credentials in code

Warning

package main

import (
	"fmt"
	"github.com/aliyun/aliyun-oss-go-sdk/oss"
	"os"
)

func main() {
    // Create an OSSClient instance. 
    // Specify the endpoint of the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. Specify your actual endpoint. 
    // Set yourAccessKeyId to the AccessKey ID of the RAM user and yourAccessKeySecret to the AccessKey secret of the RAM user. 
    client, err := oss.New("yourEndpoint", "yourAccessKeyId", "yourAccessKeySecret")
    if err != nil {
        fmt.Println("Error:", err)
        os.Exit(-1)
    }
}

What to do next

After you configure the access credentials, you must initialize an OSSClient instance. For more information, see Initialization.