:Configurar credenciais de acesso (Go SDK V1)

Escolha um provedor de credenciais

O OSS oferece diversas formas de inicializar um provedor de credenciais. Escolha a que melhor atende aos requisitos de autenticação e autorização da sua aplicação.

Método 1: Usar um par de AccessKey

Se a sua aplicação é executada em um ambiente seguro e estável e precisa de acesso contínuo ao OSS sem rotação frequente de credenciais, inicialize o provedor de credenciais com o par de AccessKey (AccessKey ID e AccessKey Secret) da sua conta Alibaba Cloud ou de um usuário RAM. Esse método exige o gerenciamento manual do par de AccessKey, o que aumenta os riscos de segurança e a sobrecarga de manutenção. Para saber como obter um par de AccessKey, consulte CreateAccessKey.

Variáveis de ambiente

1. Defina as variáveis de ambiente para o seu par de AccessKey.

   macOS, Linux, or Unix

   export OSS_ACCESS_KEY_ID=<ALIBABA_CLOUD_ACCESS_KEY_ID>
   export OSS_ACCESS_KEY_SECRET=<ALIBABA_CLOUD_ACCESS_KEY_SECRET>

   Windows

   set OSS_ACCESS_KEY_ID=<ALIBABA_CLOUD_ACCESS_KEY_ID>
   set OSS_ACCESS_KEY_SECRET=<ALIBABA_CLOUD_ACCESS_KEY_SECRET>

2. Use as variáveis de ambiente para fornecer as credenciais.

   package main
   
   import (
   	"fmt"
   	"os"
   
   	"github.com/aliyun/aliyun-oss-go-sdk/oss"
   )
   
   func main() {
   	// Obtain access credentials from environment variables. Before you run this code sample, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are set.
   	provider, err := oss.NewEnvironmentVariableCredentialsProvider()
   	if err != nil {
   		fmt.Println("Error:", err)
   		os.Exit(-1)
   	}
   	// Create an OSSClient instance.
   	// Set yourEndpoint to the bucket's endpoint and yourRegion to its region.
   	// For a bucket in the China (Hangzhou) region, an example endpoint is https://oss-cn-hangzhou.aliyuncs.com and the region is cn-hangzhou.
   	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
   	clientOptions = append(clientOptions, oss.Region("yourRegion"))
   	// Set the signature version.
   	clientOptions = append(clientOptions, oss.AuthVersion(oss.AuthV4))
   	client, err := oss.New("yourEndpoint", "", "", clientOptions...)
   	if err != nil {
   		fmt.Println("Error:", err)
   		os.Exit(-1)
   	}
   	fmt.Printf("client:%#v\n", client)
   }

Credenciais estáticas

Referencie as credenciais no código por meio de variáveis. Em tempo de execução, essas variáveis são preenchidas com os valores reais das credenciais carregados a partir de variáveis de ambiente, arquivos de configuração ou outras fontes de dados externas.

O exemplo a seguir utiliza um arquivo de configuração.

go get -u github.com/go-ini/ini

1. Crie um arquivo de configuração chamado config.ini.

   [credentials]
   alibaba_cloud_access_key_id = <ALIBABA_CLOUD_ACCESS_KEY_ID>
   alibaba_cloud_access_key_secret = <ALIBABA_CLOUD_ACCESS_KEY_SECRET>

2. Use o arquivo de configuração para fornecer as credenciais.

   package main
   
   import (
   	"fmt"
   	"os"
   
   	"github.com/aliyun/aliyun-oss-go-sdk/oss"
   	"gopkg.in/ini.v1"
   )
   
   type defaultCredentials struct {
   	config *oss.Config
   }
   
   func (defCre *defaultCredentials) GetAccessKeyID() string {
   	return defCre.config.AccessKeyID
   }
   
   func (defCre *defaultCredentials) GetAccessKeySecret() string {
   	return defCre.config.AccessKeySecret
   }
   
   func (defCre *defaultCredentials) GetSecurityToken() string {
   	return defCre.config.SecurityToken
   }
   
   type defaultCredentialsProvider struct {
   	config *oss.Config
   }
   
   func (defBuild *defaultCredentialsProvider) GetCredentials() oss.Credentials {
   	return &defaultCredentials{config: defBuild.config}
   }
   func NewDefaultCredentialsProvider(accessID, accessKey, token string) (defaultCredentialsProvider, error) {
   	var provider defaultCredentialsProvider
   	if accessID == "" {
   		return provider, fmt.Errorf("access key id is empty!")
   	}
   	if accessKey == "" {
   		return provider, fmt.Errorf("access key secret is empty!")
   	}
   	config := &oss.Config{
   		AccessKeyID:     accessID,
   		AccessKeySecret: accessKey,
   		SecurityToken:   token,
   	}
   	return defaultCredentialsProvider{
   		config,
   	}, nil
   }
   
   func main() {
   	cfg, err := ini.Load("config.ini")
   	if err != nil {
   		fmt.Println("Error loading config file:", err)
   		return
   	}
   	accessKeyID := cfg.Section("credentials").Key("alibaba_cloud_access_key_id").String()
   	accessKeySecret := cfg.Section("credentials").Key("alibaba_cloud_access_key_secret").String()
   	provider, err := NewDefaultCredentialsProvider(accessKeyID, accessKeySecret, "")
   	if err != nil {
   		fmt.Println("Error:", err)
   		os.Exit(-1)
   	}
   	// Set yourEndpoint to the bucket's endpoint and yourRegion to its region.
   	// For a bucket in the China (Hangzhou) region, an example endpoint is https://oss-cn-hangzhou.aliyuncs.com and the region is cn-hangzhou.
   	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
   	clientOptions = append(clientOptions, oss.Region("yourRegion"))
   	// Set the signature version.
   	clientOptions = append(clientOptions, oss.AuthVersion(oss.AuthV4))
   	client, err := oss.New("yourEndpoint", "", "", clientOptions...)
   	if err != nil {
   		fmt.Println("Error:", err)
   		os.Exit(-1)
   	}
   	fmt.Printf("client:%#v\n", client)
   }

Método 2: Usar um token STS

Se a sua aplicação requer acesso temporário ao OSS, inicialize o provedor de credenciais com credenciais de acesso temporárias (AccessKey ID, AccessKey Secret e um token de segurança) obtidas do Security Token Service (STS). Esse método exige o gerenciamento e a renovação manual do token STS, o que introduz riscos de segurança e sobrecarga de manutenção. Para saber como obter um token STS, consulte AssumeRole.

1. Defina as variáveis de ambiente para suas credenciais temporárias.

   macOS, Linux, or Unix

   export OSS_ACCESS_KEY_ID=<ALIBABA_CLOUD_ACCESS_KEY_ID>
   export OSS_ACCESS_KEY_SECRET=<ALIBABA_CLOUD_ACCESS_KEY_SECRET>
   export OSS_SESSION_TOKEN=<ALIBABA_CLOUD_SECURITY_TOKEN>

   Windows

   set OSS_ACCESS_KEY_ID=<ALIBABA_CLOUD_ACCESS_KEY_ID>
   set OSS_ACCESS_KEY_SECRET=<ALIBABA_CLOUD_ACCESS_KEY_SECRET>
   set OSS_SESSION_TOKEN=<ALIBABA_CLOUD_SECURITY_TOKEN>

2. Use as variáveis de ambiente para fornecer as credenciais.

   package main
   
   import (
   	"fmt"
   	"os"
   
   	"github.com/aliyun/aliyun-oss-go-sdk/oss"
   )
   
   func main() {
   	// Obtain access credentials from environment variables. Before you run this code sample, make sure that the OSS_ACCESS_KEY_ID, OSS_ACCESS_KEY_SECRET, and OSS_SESSION_TOKEN environment variables are set.
   	provider, err := oss.NewEnvironmentVariableCredentialsProvider()
   	if err != nil {
   		fmt.Println("Error:", err)
   		os.Exit(-1)
   	}
   	// Create an OSSClient instance.
   	// Set yourEndpoint to the bucket's endpoint and yourRegion to its region.
   	// For a bucket in the China (Hangzhou) region, an example endpoint is https://oss-cn-hangzhou.aliyuncs.com and the region is cn-hangzhou.
   	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
   	clientOptions = append(clientOptions, oss.Region("yourRegion"))
   	// Set the signature version.
   	clientOptions = append(clientOptions, oss.AuthVersion(oss.AuthV4))
   	client, err := oss.New("yourEndpoint", "", "", clientOptions...)
   	if err != nil {
   		fmt.Println("Error:", err)
   		os.Exit(-1)
   	}
   	fmt.Printf("client:%#v\n", client)
   }

Método 3: Usar um ARN de função RAM

Se a sua aplicação requer acesso autorizado ao OSS — por exemplo, para acesso entre contas —, inicialize o provedor de credenciais com um ARN de função RAM. Esse método utiliza um token STS. O SDK obtém automaticamente um token STS do STS ao assumir o ARN da função RAM especificada e renova o token antes de sua expiração. Você também pode atribuir uma política para restringir as permissões da função RAM a um conjunto menor. Esse método exige que você forneça um par de AccessKey, o que introduz riscos de segurança e sobrecarga de manutenção. Para saber como obter um par de AccessKey, consulte Create an AccessKey pair for a RAM user. Para saber como obter um ARN de função RAM, consulte Create a RAM role.

1. Adicione a dependência de credenciais.

   go get github.com/aliyun/credentials-go/credentials

2. Configure as credenciais de acesso.

   package main
   
   import (
   	"fmt"
   	"os"
   
   	"github.com/aliyun/aliyun-oss-go-sdk/oss"
   	"github.com/aliyun/credentials-go/credentials"
   )
   
   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 {
   	cred, _ := defBuild.cred.GetCredential()
   	return &Credentials{
   		AccessKeyId:     *cred.AccessKeyId,
   		AccessKeySecret: *cred.AccessKeySecret,
   		SecurityToken:   *cred.SecurityToken,
   	}
   }
   
   func NewRamRoleArnCredentialsProvider(credential credentials.Credential) defaultCredentialsProvider {
   	return defaultCredentialsProvider{
   		cred: credential,
   	}
   }
   
   func main() {
   	config := new(credentials.Config).
   		// Specify the credential type. Set the value to ram_role_arn.
   		SetType("ram_role_arn").
   		// Obtain the AccessKey pair (AccessKeyId and AccessKeySecret) of the RAM user from environment variables.
   		SetAccessKeyId(os.Getenv("ALIBABA_CLOUD_ACCESS_KEY_ID")).
   		SetAccessKeySecret(os.Getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET")).
   		// The following operations set parameter values directly. You can also add environment variables and use os.Getenv("") to set the parameters.
   		// Obtain the ARN of the RAM role. The ARN is the ID of the role to be assumed, for example, acs:ram::$accountID:role/$roleName.
   		// The default environment variable for RoleArn is ALIBABA_CLOUD_ROLE_ARN.
   		SetRoleArn("ALIBABA_CLOUD_ROLE_ARN").
   		// Specify a custom role session name to distinguish different tokens.
   		// The default environment variable for RoleSessionName is ALIBABA_CLOUD_ROLE_SESSION_NAME.
   		SetRoleSessionName("ALIBABA_CLOUD_ROLE_SESSION_NAME").
   		// (Optional) Limit the permissions of the STS token.
   		SetPolicy("").
   		// (Optional) Limit 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 := NewRamRoleArnCredentialsProvider(arnCredential)
   	// Set yourEndpoint to the bucket's endpoint and yourRegion to its region.
   	// For a bucket in the China (Hangzhou) region, an example endpoint is https://oss-cn-hangzhou.aliyuncs.com and the region is cn-hangzhou.
   	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
   	clientOptions = append(clientOptions, oss.Region("yourRegion"))
   	// Set the signature version.
   	clientOptions = append(clientOptions, oss.AuthVersion(oss.AuthV4))
   	client, err := oss.New("yourEndpoint", "", "", clientOptions...)
   	if err != nil {
   		fmt.Println("Error:", err)
   		os.Exit(-1)
   	}
   
   	fmt.Printf("client:%#v\n", client)
   }
   

Método 4: Usar uma função RAM do ECS

Se a sua aplicação é executada em uma instância ECS, em uma instância Elastic Container Instance (ECI) ou em um nó de trabalho do ACK, inicialize o provedor de credenciais com uma função RAM do ECS. Ao associar uma função RAM à instância, o SDK recupera e renova automaticamente os tokens STS temporários. Esse método melhora a segurança ao eliminar a necessidade de gerencie pares de AccessKey ou tokens STS manualmente. Para saber como obter uma função RAM do ECS, consulte Create a RAM role.

1. Adicione a dependência de credenciais.

   go get github.com/aliyun/credentials-go/credentials

2. Configure uma função RAM do ECS como credenciais de acesso.

   package main
   
   import (
   	"fmt"
   	"os"
   
   	"github.com/aliyun/aliyun-oss-go-sdk/oss"
   	"github.com/aliyun/credentials-go/credentials"
   )
   
   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 {
   	cred, _ := defBuild.cred.GetCredential()
   	return &Credentials{
   		AccessKeyId:     *cred.AccessKeyId,
   		AccessKeySecret: *cred.AccessKeySecret,
   		SecurityToken:   *cred.SecurityToken,
   	}
   }
   
   func NewEcsCredentialsProvider(credential credentials.Credential) CredentialsProvider {
   	return CredentialsProvider{
   		cred: credential,
   	}
   }
   
   func main() {
   	config := new(credentials.Config).
   		// Specify the credential type. Set the value to ecs_ram_role.
   		SetType("ecs_ram_role").
   		// (Optional) Specify the role name. If you do not specify a role name, the SDK automatically obtains the role. Specify a role name to reduce requests.
   		SetRoleName("RoleName")
   
   	ecsCredential, err := credentials.NewCredential(config)
   	if err != nil {
   		return
   	}
   	provider := NewEcsCredentialsProvider(ecsCredential)
   	// Set yourEndpoint to the bucket's endpoint and yourRegion to its region.
   	// For a bucket in the China (Hangzhou) region, an example endpoint is https://oss-cn-hangzhou.aliyuncs.com and the region is cn-hangzhou.
   	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
   	clientOptions = append(clientOptions, oss.Region("yourRegion"))
   	// Set the signature version.
   	clientOptions = append(clientOptions, oss.AuthVersion(oss.AuthV4))
   	client, err := oss.New("yourEndpoint", "", "", clientOptions...)
   	if err != nil {
   		fmt.Println("Error:", err)
   		os.Exit(-1)
   	}
   	fmt.Printf("client:%#v\n", client)
   
   }

Método 5: Usar um ARN de função OIDC

Após configure uma função RAM para os nós de trabalho no ACK, as aplicações nos pods desses nós podem obter o token STS da função associada por meio do Metadata Service, de forma semelhante às aplicações implantadas no ECS. No entanto, ao implantar aplicações não confiáveis no cluster de contêineres — por exemplo, aplicações enviadas por seus clientes com código fechado —, talvez você não queira que elas obtenham o token STS da função RAM da instância associada aos nós de trabalho. Para proteger seus recursos cloud e, ao mesmo tempo, permitir que essas aplicações não confiáveis obtenham com segurança o token STS necessário e alcancem a minimização de permissões em nível de aplicação, utilize o recurso RAM Roles for Service Accounts (RRSA). Esse método usa um token STS. O cluster de contêineres da Alibaba Cloud cria e monta o arquivo de token OIDC da conta de service correspondente para diferentes pods de aplicação e injeta as informações de configuração relevantes nas variáveis de ambiente. A ferramenta de credenciais obtém a configuração das variáveis de ambiente e chama a operação AssumeRoleWithOIDC do STS para trocar o token OIDC por um token STS vinculado à função. Esse método não exige que você forneça um par de AccessKey ou token STS, eliminando os riscos do gerenciamento manual. Para mais informações, consulte Use RRSA for pod-level access control.

Método 6: Usar credenciais do contexto do Function Compute

Se a função da sua aplicação é executada no Function Compute (FC), inicialize o provedor de credenciais com as credenciais do contexto do FC. Esse método utiliza um token STS. Com base na função configure para o FC, o service obtém um token STS ao assumir uma função de service e o passa para a sua aplicação por meio do parâmetro de credenciais no contexto. Esse token STS é válido por 36 horas e não pode ser modificado. Como o tempo máximo de execução de uma função é de 24 horas, o token permanece válido durante toda a execução, eliminando a necessidade de lógica de renovação manual. Esse método não exige que você forneça um par de AccessKey ou token STS, o que elimina os riscos do gerenciamento manual. Para saber como conceder permissões ao FC para acessar o OSS, consulte Use a function role to access other cloud services.

1. Adicione as dependências do contexto do FC.

   go get github.com/aliyun/fc-runtime-go-sdk/fc
   go get github.com/aliyun/fc-runtime-go-sdk/fccontext

2. Inicialize o provedor de credenciais com as credenciais do contexto do FC.

   package main
   
   import (
   	"context"
   	"fmt"
   	"github.com/aliyun/aliyun-oss-go-sdk/oss"
   	"github.com/aliyun/fc-runtime-go-sdk/fc"
   	"github.com/aliyun/fc-runtime-go-sdk/fccontext"
   )
   
   type GetObjectContext struct {
   	OutputRoute string `json:"outputRoute"`
   	OutputToken string `json:"outputToken"`
   	InputOssUrl string `json:"inputOssUrl"`
   }
   
   type StructEvent struct {
   	GetObjectContext GetObjectContext `json:"getObjectContext"`
   }
   
   func HandleRequest(ctx context.Context, event StructEvent) error {
   	endpoint := event.GetObjectContext.OutputRoute
   	fctx, _ := fccontext.FromContext(ctx)
   	client, err := oss.New(endpoint, fctx.Credentials.AccessKeyId, fctx.Credentials.AccessKeySecret, oss.SecurityToken(fctx.Credentials.SecurityToken))
   	if err != nil {
   		return fmt.Errorf("client new error: %v", err)
   	}
   	fmt.Printf("client:%#v\n", client)
   	return nil
   }
   
   func main() {
   	fc.Start(HandleRequest)
   }

Método 7: Usar um CredentialsURI

Se a sua aplicação precisa obter credenciais da Alibaba Cloud de um sistema externo para um gerenciamento flexível de credenciais e acesso sem chaves, inicialize o provedor de credenciais com um CredentialsURI. Esse método utiliza um token STS. A ferramenta de credenciais obtém um token STS do URI fornecido para inicializar o cliente de credenciais. Esse método não exige que você forneça um par de AccessKey ou token STS, o que elimina os riscos do gerenciamento manual. O service de backend que responde ao CredentialsURI deve implementar a lógica de renovação automática do token STS para garantir que sua aplicação sempre disponha de credenciais válidas.

1. Para que o SDK analise e utilize corretamente o token STS, o service no URI especificado deve obedecer ao seguinte protocolo de resposta:

   • Código de status da resposta: 200

   • Estrutura do corpo da resposta:

     {
         "Code": "Success",
         "AccessKeySecret": "AccessKeySecret",
         "AccessKeyId": "AccessKeyId",
         "Expiration": "2021-09-26T03:46:38Z",
         "SecurityToken": "SecurityToken"
     }

2. Adicione a dependência de credenciais.

   go get github.com/aliyun/credentials-go/credentials

3. Configure o CredentialsURI como credenciais de acesso.

   package main
   
   import (
   	"fmt"
   	"os"
   
   	"github.com/aliyun/aliyun-oss-go-sdk/oss"
   	"github.com/aliyun/credentials-go/credentials"
   )
   
   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 {
   	cred, _ := defBuild.cred.GetCredential()
   	return &Credentials{
   		AccessKeyId:     *cred.AccessKeyId,
   		AccessKeySecret: *cred.AccessKeySecret,
   		SecurityToken:   *cred.SecurityToken,
   	}
   }
   
   func NewCredentialsUriCredentialsProvider(credential credentials.Credential) CredentialsProvider {
   	return CredentialsProvider{
   		cred: credential,
   	}
   }
   
   func main() {
   	config := new(credentials.Config).
   		// Specify the credential type. Set the value to credentials_uri.
   		SetType("credentials_uri").
   		// Specify the URL. You can also set this parameter by using an environment variable and os.Getenv("").
   		// The default environment variable for the URL is ALIBABA_CLOUD_CREDENTIALS_URI.
   		SetURLCredential("http://127.0.0.1")
   	uriCredential, err := credentials.NewCredential(config)
   	if err != nil {
   		return
   	}
   	provider := NewCredentialsUriCredentialsProvider(uriCredential)
   	// Set yourEndpoint to the bucket's endpoint and yourRegion to its region.
   	// For a bucket in the China (Hangzhou) region, an example endpoint is https://oss-cn-hangzhou.aliyuncs.com and the region is cn-hangzhou.
   	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
   	clientOptions = append(clientOptions, oss.Region("yourRegion"))
   	// Set the signature version.
   	clientOptions = append(clientOptions, oss.AuthVersion(oss.AuthV4))
   	client, err := oss.New("yourEndpoint", "", "", clientOptions...)
   	if err != nil {
   		fmt.Println("Error:", err)
   		os.Exit(-1)
   	}
   	fmt.Printf("client:%#v\n", client)
   }
   

Método 8: Usar um par de AccessKey com rotação automática

Se a sua aplicação requer acesso de longo prazo ao OSS, mas opera em um ambiente com alto risco de vazamento de par de AccessKey e necessita de rotação frequente de credenciais, inicialize o provedor de credenciais com um ClientKey. Esse método utiliza um par de AccessKey. Com o ClientKey, o Key Management Service (KMS) rotaciona automática e periodicamente o par de AccessKey do usuário RAM gerenciado, transformando um par de AccessKey estático em dinâmico para reduzir o risco de vazamentos. Além da rotação periódica, o KMS também suporta rotação imediata, permitindo substituir rapidamente um par de AccessKey comprometido. Esse método elimina a necessidade de gerencie manualmente um par de AccessKey, reduzindo os riscos de segurança e a sobrecarga de manutenção. Para saber como obter um ClientKey, consulte Create an application access point.

1. Execute o comando go get para usar o Secret Client no seu projeto.

   go get -u github.com/aliyun/aliyun-secretsmanager-client-go

2. Crie um arquivo de configuração chamado secretsmanager.properties.

   # Credential type
   credentials_type=client_key
   
   # Read the decryption password for the client key. Supports reading from an environment variable or a file.
   client_key_password_from_env_variable=#your client key private key password environment variable name#
   client_key_password_from_file_path=#your client key private key password file path#
   
   # Path to the ClientKey private key file
   client_key_private_key_path=#your client key private key file path#
   
   # Associated KMS region
   cache_client_region_id=[{"regionId":"#regionId#"}]

3. Inicialize o cliente OSS com as credenciais rotacionadas.

   package main
   
   import (
   	"encoding/json"
   	"fmt"
   	"os"
   
   	"github.com/aliyun/aliyun-oss-go-sdk/oss"
   	"github.com/aliyun/aliyun-secretsmanager-client-go/sdk"
   )
   
   type defaultCredentials struct {
   	config *oss.Config
   }
   
   func (defCre *defaultCredentials) GetAccessKeyID() string {
   	return defCre.config.AccessKeyID
   }
   
   func (defCre *defaultCredentials) GetAccessKeySecret() string {
   	return defCre.config.AccessKeySecret
   }
   
   func (defCre *defaultCredentials) GetSecurityToken() string {
   	return defCre.config.SecurityToken
   }
   
   type defaultCredentialsProvider struct {
   	config *oss.Config
   }
   
   func (defBuild *defaultCredentialsProvider) GetCredentials() oss.Credentials {
   	return &defaultCredentials{config: defBuild.config}
   }
   func NewDefaultCredentialsProvider(accessID, accessKey, token string) (defaultCredentialsProvider, error) {
   	var provider defaultCredentialsProvider
   	if accessID == "" {
   		return provider, fmt.Errorf("access key id is empty!")
   	}
   	if accessKey == "" {
   		return provider, fmt.Errorf("access key secret is empty!")
   	}
   	config := &oss.Config{
   		AccessKeyID:     accessID,
   		AccessKeySecret: accessKey,
   		SecurityToken:   token,
   	}
   	return defaultCredentialsProvider{
   		config,
   	}, nil
   }
   
   func main() {
   	client, err := sdk.NewClient()
   	if err != nil {
   		fmt.Println("Error:", err)
   		os.Exit(-1)
   	}
   	secretInfo, err := client.GetSecretInfo("#secretName#")
   	if err != nil {
   		fmt.Println("Error:", err)
   		os.Exit(-1)
   	}
   	fmt.Printf("SecretValue:%s\n", secretInfo.SecretValue)
   	var m map[string]string
   	err = json.Unmarshal([]byte(secretInfo.SecretValue), &m)
   	if err != nil {
   		fmt.Println("Error decoding JSON:", err)
   		os.Exit(-1)
   	}
   	accessKeyId := m["AccessKeyId"]
   	accessKeySecret := m["AccessKeySecret"]
   	provider, err := NewDefaultCredentialsProvider(accessKeyId, accessKeySecret, "")
   	if err != nil {
   		fmt.Println("Error:", err)
   		os.Exit(-1)
   	}
   	// Set yourEndpoint to the bucket's endpoint and yourRegion to its region.
   	// For a bucket in the China (Hangzhou) region, an example endpoint is https://oss-cn-hangzhou.aliyuncs.com and the region is cn-hangzhou.
   	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
   	clientOptions = append(clientOptions, oss.Region("yourRegion"))
   	// Set the signature version.
   	clientOptions = append(clientOptions, oss.AuthVersion(oss.AuthV4))
   	ossClient, err := oss.New("yourEndpoint", "", "", clientOptions...)
   	if err != nil {
   		fmt.Println("Error:", err)
   		os.Exit(-1)
   	}
   	fmt.Printf("client:%#v\n", ossClient)
   }

Método 9: Implementar um provedor de credenciais personalizado

Se nenhum dos métodos de configuração de credenciais anteriores atender às suas necessidades, crie um provedor personalizado implementando a interface oss.CredentialsProvider.

package main

import (
	"fmt"
	"os"

	"github.com/aliyun/aliyun-oss-go-sdk/oss"
)

type CustomerCredentialsProvider struct {
	config *oss.Config
}

func NewCustomerCredentialsProvider() CustomerCredentialsProvider {
	return CustomerCredentialsProvider{}
}

func (s CustomerCredentialsProvider) GetCredentials() oss.Credentials {
	// Return long-term access credentials.
	config := &oss.Config{
		AccessKeyID:     "id",
		AccessKeySecret: "secret",
	}
	return &CustomerCredentialsProvider{
		config,
	}
	// Return temporary access credentials.
	//config := &oss.Config{
	//    AccessKeyID:     "id",
	//    AccessKeySecret: "secret",
	//    SecurityToken:   "token",
	//}
	//return &CustomerCredentialsProvider{
	//    config,
	//}
}

func (s *CustomerCredentialsProvider) GetAccessKeyID() string {
	return s.config.AccessKeyID
}

func (s *CustomerCredentialsProvider) GetAccessKeySecret() string {
	return s.config.AccessKeySecret
}

func (s *CustomerCredentialsProvider) GetSecurityToken() string {
	return s.config.SecurityToken
}

func main() {
	provider := NewCustomerCredentialsProvider()
	// Set yourEndpoint to the bucket's endpoint and yourRegion to its region.
	// For a bucket in the China (Hangzhou) region, an example endpoint is https://oss-cn-hangzhou.aliyuncs.com and the region is cn-hangzhou.
	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
	clientOptions = append(clientOptions, oss.Region("yourRegion"))
	// Set the signature version.
	clientOptions = append(clientOptions, oss.AuthVersion(oss.AuthV4))
	client, err := oss.New("yourEndpoint", "", "", clientOptions...)
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}
	fmt.Printf("client:%#v\n", client)
}