Object Storage Service：Konfigurasikan kredensial akses (Go SDK V1)

Pilih penyedia kredensial

OSS mendukung beberapa cara untuk menginisialisasi penyedia kredensial. Pilih metode yang sesuai dengan kebutuhan autentikasi dan otorisasi skenario Anda.

Metode 1: Gunakan pasangan AccessKey

Jika aplikasi Anda berjalan di lingkungan aman dan stabil—tidak rentan terhadap serangan eksternal, memerlukan akses jangka panjang ke OSS, dan tidak dapat menggunakan kredensial yang sering diputar—Anda dapat menginisialisasi penyedia kredensial dengan pasangan AccessKey (ID AccessKey dan Rahasia AccessKey) dari Akun Alibaba Cloud atau Pengguna Resource Access Management (RAM). Metode ini mengharuskan Anda memelihara pasangan AccessKey secara manual, sehingga meningkatkan risiko keamanan dan kompleksitas pemeliharaan. Untuk mendapatkan pasangan AccessKey, lihat CreateAccessKey - Buat pasangan AccessKey untuk Akun Alibaba Cloud atau Pengguna RAM.

Variabel lingkungan

1. Atur variabel lingkungan menggunakan pasangan AccessKey.

   Mac OS X/Linux/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. Gunakan variabel lingkungan untuk meneruskan informasi kredensial.

   package main
   
   import (
   	"fmt"
   	"os"
   
   	"github.com/aliyun/aliyun-oss-go-sdk/oss"
   )
   
   func main() {
   	// Dapatkan kredensial akses dari variabel lingkungan. Sebelum menjalankan kode contoh ini, pastikan variabel lingkungan OSS_ACCESS_KEY_ID dan OSS_ACCESS_KEY_SECRET telah diatur.
   	provider, err := oss.NewEnvironmentVariableCredentialsProvider()
   	if err != nil {
   		fmt.Println("Error:", err)
   		os.Exit(-1)
   	}
   	// Buat instance OSSClient.
   	// Atur yourEndpoint ke titik akhir bucket. Misalnya, jika bucket berada di wilayah China (Hangzhou), atur titik akhir ke https://oss-cn-hangzhou.aliyuncs.com. Untuk wilayah lain, gunakan titik akhir aktual.
   	// Atur yourRegion ke wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah China (Hangzhou), atur wilayah ke cn-hangzhou. Untuk wilayah lain, gunakan wilayah aktual.
   	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
   	clientOptions = append(clientOptions, oss.Region("yourRegion"))
   	// Atur versi signature.
   	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)
   }
   

Kredensial statis

Anda dapat menggunakan variabel dalam kode Anda untuk mereferensikan kredensial. Saat runtime, variabel tersebut diisi dengan nilai kredensial aktual dari variabel lingkungan, file konfigurasi, atau sumber data eksternal lainnya.

Langkah-langkah berikut menggunakan file konfigurasi sebagai contoh.

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

1. Buat file konfigurasi bernama config.ini.

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

2. Gunakan file konfigurasi untuk meneruskan informasi kredensial.

   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)
   	}
   	// Atur yourEndpoint ke titik akhir bucket. Misalnya, jika bucket berada di wilayah China (Hangzhou), atur titik akhir ke https://oss-cn-hangzhou.aliyuncs.com. Untuk wilayah lain, gunakan titik akhir aktual.
   	// Atur yourRegion ke wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah China (Hangzhou), atur wilayah ke cn-hangzhou. Untuk wilayah lain, gunakan wilayah aktual.
   	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
   	clientOptions = append(clientOptions, oss.Region("yourRegion"))
   	// Atur versi signature.
   	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)
   }
   

Metode 2: Gunakan token STS

Jika aplikasi Anda memerlukan akses sementara ke OSS, Anda dapat menginisialisasi penyedia kredensial dengan kredensial identitas sementara (ID AccessKey, Rahasia AccessKey, dan token keamanan) yang diperoleh dari Security Token Service (STS). Metode ini mengharuskan Anda memelihara token STS secara manual, sehingga meningkatkan risiko keamanan dan kompleksitas pemeliharaan. Selain itu, untuk mengakses OSS secara berulang dalam periode sementara, Anda harus me-refresh token STS secara manual. Untuk mendapatkan token STS, lihat AssumeRole - Dapatkan kredensial identitas sementara untuk peran RAM.

1. Atur variabel lingkungan menggunakan kredensial identitas sementara.

   Mac OS X/Linux/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. Meneruskan informasi kredensial melalui variabel lingkungan.

   package main
   
   import (
   	"fmt"
   	"os"
   
   	"github.com/aliyun/aliyun-oss-go-sdk/oss"
   )
   
   func main() {
   	// Dapatkan kredensial akses dari variabel lingkungan. Sebelum menjalankan kode contoh ini, pastikan variabel lingkungan OSS_ACCESS_KEY_ID, OSS_ACCESS_KEY_SECRET, dan OSS_SESSION_TOKEN telah diatur.
   	provider, err := oss.NewEnvironmentVariableCredentialsProvider()
   	if err != nil {
   		fmt.Println("Error:", err)
   		os.Exit(-1)
   	}
   	// Buat instance OSSClient.
   	// Atur yourEndpoint ke titik akhir bucket. Misalnya, jika bucket berada di wilayah China (Hangzhou), atur titik akhir ke https://oss-cn-hangzhou.aliyuncs.com. Untuk wilayah lain, gunakan titik akhir aktual.
   	// Atur yourRegion ke wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah China (Hangzhou), atur wilayah ke cn-hangzhou. Untuk wilayah lain, gunakan wilayah aktual.
   	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
   	clientOptions = append(clientOptions, oss.Region("yourRegion"))
   	// Atur versi signature.
   	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)
   }
   

Metode 3: Gunakan RAMRoleARN

Jika aplikasi Anda memerlukan akses resmi ke OSS, seperti untuk akses lintas akun, Anda dapat menginisialisasi penyedia kredensial menggunakan RAMRoleARN. Metode ini menggunakan token Security Token Service (STS) sebagai kredensial dasar. Saat Anda menentukan Nama Sumber Daya Alibaba Cloud (ARN) dari peran RAM, alat kredensial mendapatkan token STS dari STS dan secara otomatis me-refresh token tersebut sebelum kedaluwarsa. Anda juga dapat mengatur parameter policy untuk lebih membatasi izin peran RAM. Perhatikan bahwa metode ini mengharuskan Anda menyediakan pasangan AccessKey, sehingga meningkatkan risiko keamanan dan kompleksitas pemeliharaan. Untuk informasi selengkapnya tentang cara membuat pasangan AccessKey, lihat CreateAccessKey - Buat pasangan AccessKey untuk Pengguna RAM. Untuk informasi selengkapnya tentang cara membuat peran RAM, lihat CreateRole - Buat peran RAM.

1. Tambahkan dependensi kredensial.

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

2. Konfigurasikan kredensial akses.

   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).
   		// Tentukan jenis kredensial. Nilainya tetap ram_role_arn.
   		SetType("ram_role_arn").
   		// Dapatkan pasangan AccessKey (AccessKeyId dan AccessKeySecret) dari Pengguna RAM dari variabel lingkungan.
   		SetAccessKeyId(os.Getenv("ALIBABA_CLOUD_ACCESS_KEY_ID")).
   		SetAccessKeySecret(os.Getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET")).
   		// Secara default, operasi berikut langsung mengisi nilai parameter. Anda juga dapat mengatur parameter yang sesuai dengan menambahkan variabel lingkungan dan menggunakan os.Getenv("<variable_name>").
   		// Dapatkan ARN dari peran RAM yang akan diasumsikan dari variabel lingkungan. Formatnya adalah acs:ram::$accountID:role/$roleName.
   		SetRoleArn("ALIBABA_CLOUD_ROLE_ARN"). // Variabel lingkungan default untuk RoleArn adalah ALIBABA_CLOUD_ROLE_ARN.
   		// Tentukan nama sesi peran kustom untuk membedakan token yang berbeda.
   		SetRoleSessionName("ALIBABA_CLOUD_ROLE_SESSION_NAME"). // Variabel lingkungan default untuk RoleSessionName adalah ALIBABA_CLOUD_ROLE_SESSION_NAME.
   		// (Opsional) Batasi izin token STS.
   		SetPolicy("").
   		// (Opsional) Tentukan periode validitas token STS.
   		SetRoleSessionExpiration(3600)
   
   	arnCredential, err := credentials.NewCredential(config)
   	if err != nil {
   		fmt.Println("Error:", err)
   		os.Exit(-1)
   	}
   
   	provider := NewRamRoleArnCredentialsProvider(arnCredential)
   	// Atur yourEndpoint ke titik akhir bucket. Misalnya, jika bucket berada di wilayah China (Hangzhou), atur titik akhir ke https://oss-cn-hangzhou.aliyuncs.com. Untuk wilayah lain, gunakan titik akhir aktual.
   	// Atur yourRegion ke wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah China (Hangzhou), atur wilayah ke cn-hangzhou. Untuk wilayah lain, gunakan wilayah aktual.
   	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
   	clientOptions = append(clientOptions, oss.Region("yourRegion"))
   	// Atur versi signature.
   	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)
   }
   

Metode 4: Gunakan ECSRAMRole

Jika aplikasi Anda berjalan pada instance ECS, instance ECI, atau node pekerja Container Service for Kubernetes, Anda dapat menginisialisasi penyedia kredensial menggunakan ECSRAMRole. Metode ini menggunakan token Security Token Service (STS) sebagai kredensial dasar. ECSRAMRole memungkinkan Anda mengaitkan peran dengan instance ECS, instance ECI, atau node pekerja Container Service for Kubernetes untuk secara otomatis me-refresh token STS di dalam instance. Metode ini tidak mengharuskan Anda menyediakan pasangan AccessKey atau token STS, sehingga menghilangkan risiko pemeliharaan manual. Untuk mendapatkan ECSRAMRole, lihat CreateRole - Buat peran RAM.

1. Tambahkan dependensi kredensial.

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

2. Konfigurasikan ECSRAMRole sebagai kredensial akses.

   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).
   		// Tentukan jenis kredensial. Nilainya tetap ecs_ram_role.
   		SetType("ecs_ram_role").
   		// (Opsional) Tentukan nama peran. Jika Anda tidak menentukan nama peran, OSS secara otomatis mendapatkan peran tersebut. Tentukan nama peran untuk mengurangi jumlah permintaan.
   		SetRoleName("RoleName")
   
   	ecsCredential, err := credentials.NewCredential(config)
   	if err != nil {
   		return
   	}
   	provider := NewEcsCredentialsProvider(ecsCredential)
   	// Atur yourEndpoint ke titik akhir bucket. Misalnya, jika bucket berada di wilayah China (Hangzhou), atur titik akhir ke https://oss-cn-hangzhou.aliyuncs.com. Untuk wilayah lain, gunakan titik akhir aktual.
   	// Atur yourRegion ke wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah China (Hangzhou), atur wilayah ke cn-hangzhou. Untuk wilayah lain, gunakan wilayah aktual.
   	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
   	clientOptions = append(clientOptions, oss.Region("yourRegion"))
   	// Atur versi signature.
   	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)
   
   }
   

Metode 5: Gunakan OIDCRoleARN

Setelah Anda mengatur peran RAM untuk node pekerja di Container Service for Kubernetes, aplikasi dalam pod pada node tersebut dapat memperoleh token Security Token Service (STS) dari peran terkait melalui layanan metadata, mirip dengan aplikasi yang dideploy di ECS. Namun, jika Anda men-deploy aplikasi tidak tepercaya pada kluster kontainer, Anda mungkin tidak ingin aplikasi tersebut memperoleh token STS dari peran RAM instans yang terkait dengan node pekerja melalui layanan metadata. Untuk memungkinkan aplikasi tidak tepercaya ini memperoleh token STS yang diperlukan secara aman dan meminimalkan izin di tingkat aplikasi tanpa mengorbankan keamanan resource cloud Anda, Anda dapat menggunakan fitur RAM Roles for Service Accounts (RRSA). Metode ini menggunakan token STS sebagai kredensial dasar. Kluster kontainer Alibaba Cloud membuat dan memasang file token OpenID Connect (OIDC) akun layanan yang sesuai untuk pod aplikasi yang berbeda serta menyuntikkan informasi konfigurasi terkait ke dalam variabel lingkungan. Alat kredensial memperoleh informasi konfigurasi dari variabel lingkungan dan memanggil operasi AssumeRoleWithOIDC dari STS untuk menukar token OIDC dengan token STS dari peran yang terikat. Metode ini tidak mengharuskan Anda menyediakan pasangan AccessKey atau token STS, sehingga menghilangkan risiko pemeliharaan manual. Untuk informasi selengkapnya, lihat Isolasi izin pod berdasarkan RRSA.

Metode 6: Gunakan kredensial dari konteks Function Compute

Jika fungsi aplikasi Anda berjalan di Function Compute, Anda dapat menginisialisasi penyedia kredensial menggunakan kredensial dari konteks Function Compute. Metode ini menggunakan token Security Token Service (STS) sebagai kredensial dasar. Function Compute memperoleh token STS dengan mengasumsikan peran layanan yang dikonfigurasi untuk fungsi tersebut, lalu meneruskan token STS ke aplikasi Anda melalui parameter Credentials dalam konteks. Token STS berlaku selama 36 jam dan tidak dapat dimodifikasi. Waktu eksekusi maksimum suatu fungsi adalah 24 jam. Oleh karena itu, token STS tidak kedaluwarsa selama eksekusi fungsi, dan Anda tidak perlu me-refresh-nya. Metode ini tidak mengharuskan Anda menyediakan pasangan AccessKey atau token STS, sehingga menghilangkan risiko pemeliharaan manual. Untuk mempelajari cara memberikan izin Function Compute untuk mengakses OSS, lihat Berikan izin Function Compute untuk mengakses layanan Alibaba Cloud lainnya menggunakan peran fungsi.

1. Tambahkan dependensi konteks Function Compute.

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

2. Inisialisasi penyedia kredensial menggunakan kredensial dari konteks Function Compute.

   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)
   }
   

Metode 7: Gunakan CredentialsURI

Jika aplikasi Anda perlu mendapatkan kredensial Alibaba Cloud dari sistem eksternal untuk manajemen kredensial fleksibel dan akses tanpa kunci, Anda dapat menginisialisasi penyedia kredensial menggunakan CredentialsURI. Metode ini menggunakan token Security Token Service (STS) sebagai kredensial dasar. Alat kredensial memperoleh token STS dari URI yang Anda sediakan untuk menyelesaikan inisialisasi klien kredensial. Metode ini tidak mengharuskan Anda menyediakan pasangan AccessKey atau token STS, sehingga menghilangkan risiko pemeliharaan manual. Layanan backend yang menyediakan respons CredentialsURI harus mengimplementasikan logika untuk secara otomatis me-refresh token STS guna memastikan aplikasi Anda selalu dapat memperoleh kredensial yang valid.

1. Agar alat kredensial dapat mengurai dan menggunakan token STS dengan benar, URI harus mengikuti protokol respons berikut:

   • Kode status respons: 200

   • Struktur tubuh respons:

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

2. Tambahkan dependensi kredensial.

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

3. Konfigurasikan CredentialsURI sebagai kredensial akses.

   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).
   		// Tentukan jenis kredensial. Nilainya tetap credentials_uri.
   		SetType("credentials_uri").
   		// Tentukan URL. Anda juga dapat meneruskan parameter dengan mengatur variabel lingkungan dan menggunakan os.Getenv("<variable_name>").
   		// Variabel lingkungan default untuk URLCredential adalah ALIBABA_CLOUD_CREDENTIALS_URI.
   		SetURLCredential("http://127.0.0.1")
   	uriCredential, err := credentials.NewCredential(config)
   	if err != nil {
   		return
   	}
   	provider := NewCredentialsUriCredentialsProvider(uriCredential)
   	// Atur yourEndpoint ke titik akhir bucket. Misalnya, jika bucket berada di wilayah China (Hangzhou), atur titik akhir ke https://oss-cn-hangzhou.aliyuncs.com. Untuk wilayah lain, gunakan titik akhir aktual.
   	// Atur yourRegion ke wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah China (Hangzhou), atur wilayah ke cn-hangzhou. Untuk wilayah lain, gunakan wilayah aktual.
   	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
   	clientOptions = append(clientOptions, oss.Region("yourRegion"))
   	// Atur versi signature.
   	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)
   }
   

Metode 8: Gunakan pasangan AccessKey yang diputar-otomatis

Jika aplikasi Anda memerlukan akses jangka panjang ke OSS tetapi berjalan di lingkungan dengan risiko kebocoran pasangan AccessKey yang memerlukan rotasi manual yang sering, Anda dapat menginisialisasi penyedia kredensial menggunakan ClientKey. Metode ini menggunakan pasangan AccessKey sebagai kredensial dasar. Setelah Anda menggunakan ClientKey, Key Management Service (KMS) dapat secara otomatis dan berkala memutar pasangan AccessKey terkelola dari Pengguna RAM. Proses ini menjadikan pasangan AccessKey statis dari Pengguna RAM menjadi dinamis dan mengurangi risiko kebocoran. Selain rotasi berkala, KMS juga mendukung rotasi segera untuk cepat mengganti pasangan AccessKey yang bocor. Metode ini tidak mengharuskan Anda memelihara pasangan AccessKey secara manual, sehingga mengurangi risiko keamanan dan kompleksitas pemeliharaan. Untuk mendapatkan ClientKey, lihat Buat titik akses aplikasi.

1. Jalankan perintah go get untuk menggunakan klien kredensial dalam proyek Anda.

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

2. Buat file konfigurasi bernama secretsmanager.properties.

   # Jenis kredensial akses.
   credentials_type=client_key
   
   # Kata sandi dekripsi kunci klien. Anda dapat membaca kata sandi dari variabel lingkungan atau file.
   client_key_password_from_env_variable=#nama variabel lingkungan kata sandi kunci privat kunci klien Anda#
   client_key_password_from_file_path=#path file kata sandi kunci privat kunci klien Anda#
   
   # Path file kunci privat untuk Kunci Klien.
   client_key_private_key_path=#path file kunci privat kunci klien Anda#
   
   # Wilayah layanan KMS terkait.
   cache_client_region_id=[{"regionId":"#regionId#"}]

3. Bangun klien.

   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)
   	}
   	// Atur yourEndpoint ke titik akhir bucket. Misalnya, jika bucket berada di wilayah China (Hangzhou), atur titik akhir ke https://oss-cn-hangzhou.aliyuncs.com. Untuk wilayah lain, gunakan titik akhir aktual.
   	// Atur yourRegion ke wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah China (Hangzhou), atur wilayah ke cn-hangzhou. Untuk wilayah lain, gunakan wilayah aktual.
   	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
   	clientOptions = append(clientOptions, oss.Region("yourRegion"))
   	// Atur versi signature.
   	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)
   }
   

Metode 9: Sesuaikan kredensial akses

Jika metode konfigurasi kredensial sebelumnya tidak memenuhi kebutuhan Anda, Anda dapat menyesuaikan penyedia kredensial dengan mengimplementasikan antarmuka Credential Providers.

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 {
	// Kembalikan kredensial jangka panjang.
	config := &oss.Config{
		AccessKeyID:     "id",
		AccessKeySecret: "secret",
	}
	return &CustomerCredentialsProvider{
		config,
	}
	// Kembalikan kredensial sementara.
	//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()
	// Atur yourEndpoint ke titik akhir bucket. Misalnya, jika bucket berada di wilayah China (Hangzhou), atur titik akhir ke https://oss-cn-hangzhou.aliyuncs.com. Untuk wilayah lain, gunakan titik akhir aktual.
	// Atur yourRegion ke wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah China (Hangzhou), atur wilayah ke cn-hangzhou. Untuk wilayah lain, gunakan wilayah aktual.
	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
	clientOptions = append(clientOptions, oss.Region("yourRegion"))
	// Atur versi signature.
	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)
}