: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 opção que melhor atende aos requisitos de autenticação e autorização da sua aplicação.

Método 1: Usar um par de AccessKey

Se sua aplicação executa em um ambiente seguro e estável, exigindo acesso de longo prazo 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. Este 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. Utilize 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

É possível referenciar credenciais no código por meio de variáveis. Durante a execução, essas variáveis são preenchidas com os valores reais das credenciais carregadas 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

Caso sua aplicação necessite de 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 no Security Token Service (STS). Este método exige que você gerencie e atualize o token STS manualmente, 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. Utilize 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 sua aplicação requer acesso autorizado ao OSS, como para acesso entre contas, inicialize o provedor de credenciais usando um ARN de função RAM. Este método utiliza um token STS. O SDK obtém automaticamente um token STS do serviço STS assumindo o ARN da função RAM especificada e atualiza o token antes que ele expire. Também é possível atribuir uma política para restringir a função RAM a um conjunto menor de permissões. Este método exige o fornecimento de 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 Criar um par de AccessKey para um usuário RAM. Para obter informações sobre como conseguir um ARN de função RAM, veja Criar uma função RAM.

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

Quando sua aplicação executa em uma instância do ECS, 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 atualiza automaticamente os tokens STS temporários. Este método melhora a segurança ao eliminar a necessidade de gerenciar pares de AccessKey ou tokens STS manualmente. Para saber como obter uma função RAM do ECS, consulte Criar uma função RAM.

1. Adicione a dependência de credenciais.

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

2. Configure uma função RAM do ECS como credencial 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 configurar uma função RAM para os nós de trabalho no ACK, as aplicações dentro dos pods nesses 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, se você implantar aplicações não confiáveis (por exemplo, aplicações enviadas por clientes com código fechado) no cluster de contêineres, talvez 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 na nuvem e permitir que essas aplicações não confiáveis obtenham com segurança o token STS necessário, alcançando a minimização de permissões no nível da aplicação, utilize o recurso RAM Roles for Service Accounts (RRSA). Este 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 serviço 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. Este método não exige o fornecimento de um par de AccessKey ou token STS, eliminando os riscos do gerenciamento manual. Para mais informações, consulte Usar RRSA para controle de acesso no nível do pod.

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

Se a função da sua aplicação executa no Function Compute (FC), inicialize o provedor de credenciais utilizando as credenciais do contexto do FC. Este método usa um token STS. Com base na função configurada para a função do FC, o serviço obtém um token STS assumindo uma função de serviço e passa esse token para sua aplicação através 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 atualização manual. Este método não exige o fornecimento de 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 Usar uma função para acessar outros serviços de nuvem.

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 usando 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

Caso sua aplicação precise obter credenciais da Alibaba Cloud de um sistema externo para garantir gerenciamento flexível de credenciais e acesso sem chaves, inicialize o provedor de credenciais usando um CredentialsURI. Este método utiliza um token STS. A ferramenta de credenciais obtém um token STS da URI fornecida para inicializar o cliente de credenciais. Este método não exige o fornecimento de um par de AccessKey ou token STS, eliminando os riscos do gerenciamento manual. O serviço de backend que responde ao CredentialsURI deve implementar a lógica de atualização automática do token STS para garantir que sua aplicação sempre tenha credenciais válidas.

1. Para garantir que o SDK analise e utilize corretamente o token STS, o serviço na URI especificada deve seguir o protocolo de resposta abaixo:

   • 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 credencial 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 sua aplicação exige acesso de longo prazo ao OSS, mas executa em um ambiente com alto risco de vazamento de pares de AccessKey que demanda rotação manual frequente de credenciais, inicialize o provedor de credenciais usando uma ClientKey. Este método utiliza um par de AccessKey. Ao usar uma ClientKey, o Key Management Service (KMS) pode rotacionar automática e periodicamente o par de AccessKey gerenciado do usuário RAM, transformando um par 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 caso seja comprometido. Este método elimina a necessidade de gerenciar manualmente o par de AccessKey, reduzindo riscos de segurança e sobrecarga de manutenção. Para saber como obter uma ClientKey, consulte Criar um ponto de acesso à aplicação.

1. Execute o comando go get para utilizar 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

Caso nenhum dos métodos anteriores de configuração de credenciais atenda aos seus requisitos, 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)
}