Object Storage Service:OSS Go SDK V1

環境の準備

Go のビルドおよびランタイム環境をダウンロードしてインストールします。詳細については、「Go のインストール」をご参照ください。Go 1.13 以降を使用することを推奨します。

• Go 1.13 以降では、パッケージの依存関係を管理するために、デフォルトでモジュールモードが有効になっています。GOPATH を手動で設定する必要はありません。

• Go 1.12 以前の場合は、GOPATH システム環境変数を設定し、コードディレクトリを指定する必要があります。

go version コマンドを実行して、Go のバージョンを確認できます。

SDK のインストール

開発環境に応じてインストール方法を選択してください。最新の SDK バージョンを使用することを推奨します。

go get github.com/aliyun/aliyun-oss-go-sdk/oss

go get github.com/aliyun/aliyun-oss-go-sdk/oss

アクセス認証情報の設定

RAM ユーザーのアクセスキーペアを使用してアクセス認証情報を設定します。

1. RAM コンソールで、[永続的な AccessKey ペア] を持つ RAM ユーザーを作成します。 AccessKey ペアを保存し、そのユーザーに AliyunOSSFullAccess 権限を付与します。

2. RAM ユーザーのアクセスキーペアを使用して環境変数を設定します。

   Linux

   1. コマンドラインインターフェイスで次のコマンドを実行して、環境変数設定を ~/.bashrc ファイルに追記します。

      echo "export OSS_ACCESS_KEY_ID='YOUR_ACCESS_KEY_ID'" >> ~/.bashrc
      echo "export OSS_ACCESS_KEY_SECRET='YOUR_ACCESS_KEY_SECRET'" >> ~/.bashrc

   2. 次のコマンドを実行して変更を適用します。

      source ~/.bashrc

   3. 次のコマンドを実行して、環境変数が設定されていることを確認します。

      echo $OSS_ACCESS_KEY_ID
      echo $OSS_ACCESS_KEY_SECRET

   macOS

   1. ターミナルで次のコマンドを実行して、デフォルトのシェルタイプを表示します。

      echo $SHELL

   2. デフォルトのシェルタイプに基づいて、次の操作を実行します。

      Zsh

      1. 次のコマンドを実行して、環境変数設定を ~/.zshrc ファイルに追記します。

         echo "export OSS_ACCESS_KEY_ID='YOUR_ACCESS_KEY_ID'" >> ~/.zshrc
         echo "export OSS_ACCESS_KEY_SECRET='YOUR_ACCESS_KEY_SECRET'" >> ~/.zshrc

      2. 次のコマンドを実行して変更を適用します。

         source ~/.zshrc

      3. 次のコマンドを実行して、環境変数が設定されていることを確認します。

         echo $OSS_ACCESS_KEY_ID
         echo $OSS_ACCESS_KEY_SECRET

      Bash

      1. 次のコマンドを実行して、環境変数設定を ~/.bash_profile ファイルに追記します。

         echo "export OSS_ACCESS_KEY_ID='YOUR_ACCESS_KEY_ID'" >> ~/.bash_profile
         echo "export OSS_ACCESS_KEY_SECRET='YOUR_ACCESS_KEY_SECRET'" >> ~/.bash_profile

      2. 次のコマンドを実行して変更を適用します。

         source ~/.bash_profile

      3. 次のコマンドを実行して、環境変数が設定されていることを確認します。

         echo $OSS_ACCESS_KEY_ID
         echo $OSS_ACCESS_KEY_SECRET

   Windows

   CMD

   1. CMD で次のコマンドを実行します。

      setx OSS_ACCESS_KEY_ID "YOUR_ACCESS_KEY_ID"
      setx OSS_ACCESS_KEY_SECRET "YOUR_ACCESS_KEY_SECRET"

   2. 次のコマンドを実行して、環境変数が設定されていることを確認します。

      echo %OSS_ACCESS_KEY_ID%
      echo %OSS_ACCESS_KEY_SECRET%

   PowerShell

   1. PowerShell で次のコマンドを実行します。

      [Environment]::SetEnvironmentVariable("OSS_ACCESS_KEY_ID", "YOUR_ACCESS_KEY_ID", [EnvironmentVariableTarget]::User)
      [Environment]::SetEnvironmentVariable("OSS_ACCESS_KEY_SECRET", "YOUR_ACCESS_KEY_SECRET", [EnvironmentVariableTarget]::User)

   2. 次のコマンドを実行して、環境変数が設定されていることを確認します。

      [Environment]::GetEnvironmentVariable("OSS_ACCESS_KEY_ID", [EnvironmentVariableTarget]::User)
      [Environment]::GetEnvironmentVariable("OSS_ACCESS_KEY_SECRET", [EnvironmentVariableTarget]::User)

クライアントの初期化

次のサンプルコードは、China (Hangzhou) リージョンのパブリックエンドポイントを使用してクライアントを初期化し、現在のアカウントにあるバケットを一覧表示します。リージョンとエンドポイントの完全なリストについては、「リージョンとエンドポイント」をご参照ください。

package main

// OSS Go SDK V1 でクライアントを初期化するサンプルコード

import (
	"fmt"

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

func main() {

	// 環境変数からアクセス認証情報を読み込みます。OSS_ACCESS_KEY_ID と OSS_ACCESS_KEY_SECRET を設定する必要があります。
	provider, _ := oss.NewEnvironmentVariableCredentialsProvider()

	// Object Storage Service (OSS) クライアントインスタンスを作成します。
	client, _ := oss.New(
		"oss-cn-hangzhou.aliyuncs.com", // China (Hangzhou) のパブリックエンドポイントを例として使用しています。
		"",
		"",
		oss.SetCredentialsProvider(&provider),
		oss.AuthVersion(oss.AuthV4),
		oss.Region("cn-hangzhou"),
	)

	// すべてのバケットを一覧表示します。
	buckets, err := client.ListBuckets()
	if err != nil {
		fmt.Printf("Failed to list buckets: %v\n", err)
		return
	}

	// バケットリストを出力します。
	fmt.Printf("Found %d buckets:\n", len(buckets.Buckets))

	for _, bucket := range buckets.Buckets {
		fmt.Printf("%s\n", bucket.Name)
	}
}

内部エンドポイントの使用

内部ネットワーク経由で OSS にアクセスするには、OSS クライアントを初期化する際に内部エンドポイントを指定します。

// OSS クライアントインスタンスを作成します。
client, _ := oss.New(
	"oss-cn-hangzhou-internal.aliyuncs.com", // China (Hangzhou) の内部エンドポイントを例として使用しています。
	"",
	"",
	oss.SetCredentialsProvider(&provider),
	oss.AuthVersion(oss.AuthV4),
	oss.Region("cn-hangzhou"),
)

カスタムドメイン名の使用

カスタムドメイン名を使用して OSS にアクセスするには、クライアントの初期化時にそれをエンドポイントとして指定し、oss.UseCname(true) で CNAME オプションを有効にします。

カスタムドメイン名を使用する前に、バケットにカスタムドメイン名をマッピングしてください。詳細については、「カスタムドメイン名を使用した OSS へのアクセス」をご参照ください。

// カスタムドメイン名をエンドポイントとして使用するかどうかを指定します。デフォルト値は false です。
cname := oss.UseCname(true)

// OSS クライアントインスタンスを作成します。
client, _ := oss.New(
	"http://kitkat-cloud.cn", // カスタムドメイン名。
	"",
	"",
	oss.SetCredentialsProvider(&provider),
	oss.AuthVersion(oss.AuthV4),
	oss.Region("cn-hangzhou"),
	cname,
)

タイムアウト制御

oss.Timeout パラメータを使用し、HTTP 接続と読み書きのタイムアウト期間を秒単位で設定します。

// HTTP 接続のタイムアウト期間を 20 秒、HTTP 読み書きのタイムアウト期間を 60 秒に設定します。
time := oss.Timeout(20, 60)

// OSS クライアントインスタンスを作成します。
client, _ := oss.New(
	"oss-cn-hangzhou.aliyuncs.com", // China (Hangzhou) のパブリックエンドポイントを例として使用しています。
	"",
	"",
	oss.SetCredentialsProvider(&provider),
	oss.AuthVersion(oss.AuthV4),
	oss.Region("cn-hangzhou"),
	time,
)

接続プールサイズの設定

oss.MaxConns パラメータを使用して、接続プールサイズを調整します。

// アイドル接続の最大数 (MaxIdleConns) を 10 に設定します。デフォルト値は 100 です。
// ホストごとのアイドル接続の最大数 (MaxIdleConnsPerHost) を 20 に設定します。デフォルト値は 100 です。
// ホストごとの接続の最大数 (MaxConnsPerHost) を 50 に設定します。デフォルト値はありません。
conn := oss.MaxConns(10, 20, 50)

// OSS クライアントインスタンスを作成します。
client, _ := oss.New(
	"oss-cn-hangzhou.aliyuncs.com", // China (Hangzhou) のパブリックエンドポイントを例として使用しています。
	"",
	"",
	oss.SetCredentialsProvider(&provider),
	oss.AuthVersion(oss.AuthV4),
	oss.Region("cn-hangzhou"),
	conn,
)

CRC データ検証の無効化

oss.EnableCRC(false) を設定して、CRC データ検証を無効にします。

// CRC データ検証を無効にします。
crc := oss.EnableCRC(false)

// OSS クライアントインスタンスを作成します。
client, _ := oss.New(
	"oss-cn-hangzhou.aliyuncs.com", // China (Hangzhou) のパブリックエンドポイントを例として使用しています。
	"",
	"",
	oss.SetCredentialsProvider(&provider),
	oss.AuthVersion(oss.AuthV4),
	oss.Region("cn-hangzhou"),
	crc,
)

署名バージョン

次のサンプルコードは、V1 署名でクライアントを初期化する例です。V4 署名での初期化については、クライアントの初期化 をご参照ください。

package main

// OSS Go SDK V1 で V1 署名を使用してクライアントを初期化するサンプルコード

import (
	"fmt"

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

func main() {

	// 環境変数からアクセス認証情報を読み込みます。OSS_ACCESS_KEY_ID と OSS_ACCESS_KEY_SECRET を設定する必要があります。
	provider, _ := oss.NewEnvironmentVariableCredentialsProvider()

	// OSS クライアントインスタンスを作成します。
	client, _ := oss.New(
		"oss-cn-hangzhou.aliyuncs.com", // China (Hangzhou) のパブリックエンドポイントを例として使用しています。
		"",
		"",
		oss.SetCredentialsProvider(&provider),
	)

	// すべてのバケットを一覧表示します。
	buckets, err := client.ListBuckets()
	if err != nil {
		fmt.Printf("Failed to list buckets: %v\n", err)
		return
	}

	// バケットリストを出力します。
	fmt.Printf("Found %d buckets:\n", len(buckets.Buckets))

	for _, bucket := range buckets.Buckets {
		fmt.Printf("%s\n", bucket.Name)
	}
}

リクエストコンテキストの設定

リクエストコンテキストを使用して、リクエストのライフサイクルを制御できます。

リクエストコンテキストの設定は、OSS Go SDK 2.2.9 以降でのみサポートされています。

package main

// OSS Go SDK V1 でリクエストコンテキストを設定するサンプルコード

import (
	"context"
	"fmt"
	"time"

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

func main() {

	// 環境変数からアクセス認証情報を読み込みます。OSS_ACCESS_KEY_ID と OSS_ACCESS_KEY_SECRET を設定する必要があります。
	provider, _ := oss.NewEnvironmentVariableCredentialsProvider()

	// OSS クライアントインスタンスを作成します。
	client, _ := oss.New(
		"oss-cn-hangzhou.aliyuncs.com", // China (Hangzhou) のパブリックエンドポイントを例として使用しています。
		"",
		"",
		oss.SetCredentialsProvider(&provider),
		oss.AuthVersion(oss.AuthV4),
		oss.Region("cn-hangzhou"),
	)

	// バケットオブジェクトを取得します。
	bucket, _ := client.Bucket("example-bucket-hz")

	// オブジェクト情報を設定します。
	key := "oss-browser2-mac-arm64-2.1.0.dmg"       // OSS 上のオブジェクトのパス。
	file_path := "oss-browser2-mac-arm64-2.1.0.dmg" // オブジェクトを保存するローカルパス。

	// リクエストコンテキストを設定します。
	ctx := context.Background()

	// リクエストコンテキストが 5 秒で期限切れになるように指定します。
	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()

	// OSS から指定されたローカルパスにオブジェクトをダウンロードし、リクエストコンテキストを設定します。
	err := bucket.GetObjectToFile(key, file_path, oss.WithContext(ctx))
	if err != nil {
		select {
		case <-ctx.Done():
			fmt.Printf("Request canceled or timed out: %v\n", err)
		default:
			fmt.Printf("Download failed: %v\n", err)
		}
		return
	}

	fmt.Printf("Object downloaded: %s -> %s\n", key, file_path)
}

RAM ユーザーの AccessKey ペアの使用

認証情報の頻繁なローテーションなしに、長期的な OSS アクセスを必要とする、安全な環境にデプロイされたアプリケーションに適しています。Alibaba Cloud アカウントまたは RAM ユーザーの AccessKey ペア (AccessKey ID と AccessKey Secret) を使用して認証情報プロバイダーを初期化します。この方法では、AccessKey ペアの手動メンテナンスが必要であり、セキュリティリスクが生じる可能性があります。

STS の一時的なセキュリティ認証情報を使用

OSS への一時的なアクセスが必要なアプリケーションに適しています。STS から取得した一時的なセキュリティ認証情報 (AccessKey ID、AccessKey Secret、およびセキュリティトークン) を使用して、認証情報プロバイダーを初期化します。この方法では、手動で STS トークンをメンテナンスする必要があります。OSS に複数回アクセスするには、トークンの有効期限が切れる前に手動で更新する必要があります。

1. 一時的なセキュリティ認証情報を使って環境変数を設定します。

   Mac OS/Linux/Unix

   重要

   • RAM ユーザーの AccessKey ペア (AccessKey ID と AccessKey Secret) ではなく、STS から取得した一時的なセキュリティ認証情報 (AccessKey ID、AccessKey Secret、およびセキュリティトークン) を使用してください。

   • STS から取得した AccessKey ID は、「STS.」で始まります (例：「STS.****************」)。

   export OSS_ACCESS_KEY_ID=<STS_ACCESS_KEY_ID>
   export OSS_ACCESS_KEY_SECRET=<STS_ACCESS_KEY_SECRET>
   export OSS_SESSION_TOKEN=<STS_SECURITY_TOKEN>

   Windows

   重要

   • RAM ユーザーの AccessKey ペア (AccessKey ID と AccessKey Secret) ではなく、STS から取得した一時的なセキュリティ認証情報 (AccessKey ID、AccessKey Secret、およびセキュリティトークン) を使用してください。

   • STS から取得した AccessKey ID は、「STS.」で始まります (例：「STS.****************」)。

   set OSS_ACCESS_KEY_ID=<STS_ACCESS_KEY_ID>
   set OSS_ACCESS_KEY_SECRET=<STS_ACCESS_KEY_SECRET>
   set OSS_SESSION_TOKEN=<STS_SECURITY_TOKEN>

2. 環境変数経由で認証情報を渡します。

   package main
   
   import (
   	"fmt"
   	"os"
   
   	"github.com/aliyun/aliyun-oss-go-sdk/oss"
   )
   
   func main() {
   	// 環境変数からアクセス認証情報を取得します。このサンプルコードを実行する前に、OSS_ACCESS_KEY_ID、OSS_ACCESS_KEY_SECRET、および OSS_SESSION_TOKEN 環境変数が設定されていることを確認してください。
   	provider, err := oss.NewEnvironmentVariableCredentialsProvider()
   	if err != nil {
   		fmt.Println("Error:", err)
   		os.Exit(-1)
   	}
   	// oss.Client インスタンスを作成します。
   	// yourEndpoint をバケットのエンドポイントに設定します。 たとえば、バケットが China (Hangzhou) リージョンにある場合、エンドポイントを https://oss-cn-hangzhou.aliyuncs.com に設定します。 他のリージョンについては、対応するエンドポイントを設定します。
   	// yourRegion をバケットのリージョンに設定します。 たとえば、バケットが China (Hangzhou) リージョンにある場合、リージョンを cn-hangzhou に設定します。 他のリージョンについては、対応するリージョンを設定します。
   	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
   	clientOptions = append(clientOptions, oss.Region("yourRegion"))
   	// 署名バージョンを設定します。
   	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)
   }

RAM ロール ARN の使用

クロスアカウントアクセスなど、OSS への認可されたアクセスを必要とするアプリケーションに適しています。RAM ロールの ARN を指定して、認証情報プロバイダーを初期化します。認証情報ツールは AssumeRole 操作を呼び出すことで、STS トークンを自動的に取得し、有効期限が切れる前に更新します。また、policy を割り当てて、ロールをより小さな権限セットに制限することもできます。

1. 認証情報の依存関係を追加します。

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

2. AccessKey ペアと RAM ロール ARN をアクセス認証情報として設定します。

   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).
   		// 認証情報のタイプ。値を ram_role_arn に設定します。
   		SetType("ram_role_arn").
   		// RAM ユーザーの AccessKey ID と AccessKey Secret。値は環境変数から取得されます。
   		SetAccessKeyId(os.Getenv("ALIBABA_CLOUD_ACCESS_KEY_ID")).
   		SetAccessKeySecret(os.Getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET")).
   		// 以下の操作では、パラメータ値を直接使用します。環境変数を追加し、os.Getenv("<変数名>") を使用して対応するパラメータを設定することもできます。
   		// 引き受ける RAM ロールの ARN。値は環境変数から取得されます。形式： acs:ram::$accountID:role/$roleName。
   		SetRoleArn(os.Getenv("ALIBABA_CLOUD_ROLE_ARN")). // RoleArn の標準環境変数名は ALIBABA_CLOUD_ROLE_ARN です。
   		// 異なるトークンを区別するためのロールセッションのカスタム名。
   		SetRoleSessionName(os.Getenv("ALIBABA_CLOUD_ROLE_SESSION_NAME")). // RoleSessionName の標準環境変数名は ALIBABA_CLOUD_ROLE_SESSION_NAME です。
   		// (オプション) STS トークンの権限を制限します。
   		SetPolicy("").
   		// (オプション) STS トークンの有効期間を制限します。
   		SetRoleSessionExpiration(3600)
   
   	arnCredential, err := credentials.NewCredential(config)
   	if err != nil {
   		fmt.Println("Error:", err)
   		os.Exit(-1)
   	}
   
   	provider := NewRamRoleArnCredentialsProvider(arnCredential)
   	// yourEndpoint をバケットのエンドポイントに設定します。たとえば、バケットが China (Hangzhou) リージョンにある場合は、エンドポイントを https://oss-cn-hangzhou.aliyuncs.com に設定します。その他のリージョンの場合は、必要に応じてエンドポイントを設定してください。
   	// yourRegion をバケットのリージョンに設定します。たとえば、バケットが China (Hangzhou) リージョンにある場合は、リージョンを cn-hangzhou に設定します。その他のリージョンの場合は、必要に応じてリージョンを設定してください。
   	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
   	clientOptions = append(clientOptions, oss.Region("yourRegion"))
   	// 署名バージョンを設定します。
   	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)
   }

ECS インスタンス RAM ロールの使用

ECS インスタンス、ECI インスタンス、または Container Service for Kubernetes のワーカーノードで実行されるアプリケーションに推奨されます。ECS インスタンス RAM ロールは、ロールをインスタンスに関連付けることで、AccessKey ペアや STS トークンを提供することなく、STS トークンを自動的に更新できます。ECS インスタンス RAM ロールの取得方法については、RAM ロールの作成をご参照ください。ロールを ECS インスタンスに関連付ける方法については、インスタンス RAM ロールをご参照ください。

1. 認証情報の依存関係を追加できます。

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

2. ECS インスタンス RAM ロールをアクセス認証情報として設定します。

   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).
   		// 認証情報のタイプ。値を ecs_ram_role に設定します。
   		SetType("ecs_ram_role").
   		// (オプション) ロール名。このパラメーターを指定しない場合、OSS は自動的にロールを取得します。リクエスト数を減らすために、ロール名を指定することを推奨します。
   		SetRoleName("RoleName")
   
   	ecsCredential, err := credentials.NewCredential(config)
   	if err != nil {
   		return
   	}
   	provider := NewEcsCredentialsProvider(ecsCredential)
   	// yourEndpoint をバケットのエンドポイントに設定してください。たとえば、バケットが China (Hangzhou) リージョンにある場合は、エンドポイントを https://oss-cn-hangzhou.aliyuncs.com に設定します。その他のリージョンの場合は、必要に応じてエンドポイントを設定してください。
   	// yourRegion をバケットのリージョンに設定してください。たとえば、バケットが China (Hangzhou) リージョンにある場合は、リージョンを cn-hangzhou に設定します。その他のリージョンの場合は、必要に応じてリージョンを設定してください。
   	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
   	clientOptions = append(clientOptions, oss.Region("yourRegion"))
   	// 署名バージョンを設定します。
   	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)
   
   }

OIDC ロール ARN の使用

Container Service for Kubernetes (ACK) のワーカーノードにデプロイされた信頼されていないアプリケーションの場合、RAM Roles for Service Accounts (RRSA) 機能は Pod レベルの認証情報分離を提供します。RRSA は、グローバルメタサービスを介してワーカーノードのインスタンス RAM ロールを共有する代わりに、各 Pod にサービスアカウント OIDC トークンファイルをマウントし、設定を環境変数に注入します。その後、認証情報ツールは AssumeRoleWithOIDC 操作を呼び出して、OIDC トークンを STS トークンと交換します。AccessKey ペアや STS トークンは不要です。詳細については、「RRSA を使用して ServiceAccount の RAM 権限を設定し、Pod レベルの権限分離を実現する」をご参照ください。

1. 認証情報の依存関係を追加します。

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

2. OIDC RAM ロールをアクセス認証情報として設定します。

   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 NewOIDCRoleARNCredentialsProvider(credential credentials.Credential) CredentialsProvider {
   	return CredentialsProvider{
   		cred: credential,
   	}
   }
   
   func main() {
   	config := new(credentials.Config).
   		// OIDC トークンのファイルパス。
   		SetOIDCTokenFilePath(os.Getenv("ALIBABA_CLOUD_OIDC_TOKEN_FILE")).
   		// 以下の操作では、パラメータ値を直接使用します。環境変数を追加し、os.Getenv("<変数名>") を使用して対応するパラメータを設定することもできます。
   		// 認証情報のタイプ。値を oidc_role_arn に設定します。
   		SetType("oidc_role_arn").
   		// OIDC プロバイダーの ARN。形式：acs:ram::account-id:oidc-provider/provider-name。
   		SetOIDCProviderArn("acs:ram::113511544585****:oidc-provider/TestOidcProvider"). // OIDCProviderArn の標準環境変数名は ALIBABA_CLOUD_OIDC_PROVIDER_ARN です。
   		// 異なるトークンを区別するためのロールセッションのカスタム名。
   		SetRoleSessionName("role_session_name"). // RoleSessionName の標準環境変数名は ALIBABA_CLOUD_ROLE_SESSION_NAME です。
   		// 引き受けるロールの ARN。形式：acs:ram:::role/。
   		SetRoleArn("acs:ram::113511544585****:role/testoidc"). // RoleArn の標準環境変数名は ALIBABA_CLOUD_ROLE_ARN です。
   		// (オプション) ロールを引き受ける際に使用するポリシー。
   		SetPolicy("").
   		SetSessionExpiration(3600)
   	oidcCredential, err := credentials.NewCredential(config)
   	if err != nil {
   		return
   	}
   	provider := NewOIDCRoleARNCredentialsProvider(oidcCredential)
   	// yourEndpoint にはバケットのエンドポイントを設定します。例えば、バケットが China (Hangzhou) リージョンにある場合は、エンドポイントを https://oss-cn-hangzhou.aliyuncs.com に設定します。その他のリージョンの場合は、必要に応じてエンドポイントを設定してください。
   	// yourRegion にはバケットのリージョンを設定します。例えば、バケットが China (Hangzhou) リージョンにある場合は、リージョンを cn-hangzhou に設定します。その他のリージョンの場合は、必要に応じてリージョンを設定してください。
   	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
   	clientOptions = append(clientOptions, oss.Region("yourRegion"))
   	// 署名バージョンを設定します。
   	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)
   }

Function Compute コンテキストからの認証情報の使用

Function Compute にデプロイされたアプリケーション関数に適しています。Function Compute は、関数に設定されたサービスロールを引き受けることで STS トークンを取得し、コンテキスト内の Credentials パラメーターを介して渡します。この STS トークンは 36 時間有効で、関数の実行中 (最大 24 時間) に有効期限が切れることはないため、更新は不要です。したがって、AccessKey ペアや STS トークンを別途用意する必要はありません。Function Compute に OSS へのアクセス許可を付与する方法については、「関数ロールを使用して Function Compute に他の Alibaba Cloud サービスへのアクセス許可を付与する」をご参照ください。

1. Function Compute のコンテキストの依存関係を追加します。

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

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

CredentialsURI の使用

外部システムから認証情報を取得するアプリケーションに適しています。Credentials ツールは、指定された URI から STS トークンを取得し、自動的に更新します。AccessKey ペアや STS トークンは不要です。

1. Credentials ツールが STS トークンを正しく解析して使用するには、URI が以下のレスポンスプロトコルに準拠している必要があります：

   • レスポンスステータスコード： 200

   • レスポンスボディの構造：

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

2. 認証情報の依存関係を追加します。

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

3. CredentialsURI をアクセス認証情報として設定します。

   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).
   		// 認証情報の種類。値を credentials_uri に設定します。
   		SetType("credentials_uri").
   		// URL アドレスを指定します。環境変数を設定し、os.Getenv("<variable_name>") を使用してパラメーターを渡すこともできます。
   		// URLCredential の標準的な環境変数名は ALIBABA_CLOUD_CREDENTIALS_URI です。
   		SetURLCredential("http://127.0.0.1")
   	uriCredential, err := credentials.NewCredential(config)
   	if err != nil {
   		return
   	}
   	provider := NewCredentialsUriCredentialsProvider(uriCredential)
   	// yourEndpoint をバケットのエンドポイントに設定します。たとえば、バケットが China (Hangzhou) リージョンにある場合、エンドポイントを https://oss-cn-hangzhou.aliyuncs.com に設定します。他のリージョンについては、それぞれのエンドポイントを設定します。
   	// yourRegion をバケットのリージョンに設定します。たとえば、バケットが China (Hangzhou) リージョンにある場合、リージョンを cn-hangzhou に設定します。他のリージョンについては、それぞれのリージョンを設定します。
   	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
   	clientOptions = append(clientOptions, oss.Region("yourRegion"))
   	// 署名バージョンを設定します。
   	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)
   }

自動ローテーションアクセスキーペアの使用

長期的な Object Storage Service (OSS) へのアクセスが必要で、かつアクセスキーペアの漏洩リスクがある環境にデプロイされているアプリケーションに適しています。 ClientKey を使用して認証情報プロバイダーを初期化します。 Key Management Service (KMS) は、管理対象の RAM ユーザーのアクセスキーペアを定期的に自動ローテーションし、静的認証情報を動的認証情報に変換します。 また、KMS は漏洩が発生した場合の迅速な交換のために、即時ローテーションもサポートしています。 ClientKey の取得方法については、「アプリケーションアクセスポイントの作成」をご参照ください。

1. 認証情報クライアントの依存関係を追加します。

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

2. secretsmanager.properties という名前の設定ファイルを作成します。

   # アクセス認証情報の種類
   credentials_type=client_key
   
   # ClientKey の復号に使用するパスワードです。パスワードは、環境変数またはファイルから読み取ります。
   client_key_password_from_env_variable=#ClientKey 秘密鍵パスワードの環境変数名#
   client_key_password_from_file_path=#ClientKey 秘密鍵パスワードのファイルパス#
   
   # ClientKey の秘密鍵ファイルのパスです。
   client_key_private_key_path=#ClientKey の秘密鍵ファイルパス#
   
   # 関連する KMS サービスのリージョンです。
   cache_client_region_id=[{"regionId":"#regionId#"}]

3. 設定ファイルを使用して認証情報を渡します。

   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)
   	}
   	// yourEndpoint をバケットのエンドポイントに設定します。たとえば、バケットが China (Hangzhou) リージョンにある場合、エンドポイントを https://oss-cn-hangzhou.aliyuncs.com に設定します。他のリージョンについては、必要に応じてエンドポイントを設定します。
   	// yourRegion をバケットのリージョンに設定します。たとえば、バケットが China (Hangzhou) リージョンにある場合、リージョンを cn-hangzhou に設定します。他のリージョンについては、必要に応じてリージョンを設定します。
   	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
   	clientOptions = append(clientOptions, oss.Region("yourRegion"))
   	// 署名バージョンを設定します。
   	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)
   }

カスタムアクセス認証情報の使用

前述のいずれの方法も要件を満たさない場合は、認証情報プロバイダーインターフェイスを使用してカスタム認証情報プロバイダーを実装できます。以下の例は、長期的な認証情報を使用する基本的なカスタムプロバイダーの実装方法を示しています。基盤となる認証情報が STS ベースの場合は、この例とは異なり、トークンの更新を処理するロジックを実装する必要があります。

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 {
	// 長期的な認証情報を返します。
	config := &oss.Config{
		AccessKeyID:     "id",
		AccessKeySecret: "secret",
	}
	return &CustomerCredentialsProvider{
		config,
	}
	// 一時的な認証情報を返します。
	//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()
	// yourEndpoint を、バケットが配置されているリージョンのエンドポイントに置き換えます。 たとえば、バケットが China (Hangzhou) リージョンにある場合、エンドポイントは https://oss-cn-hangzhou.aliyuncs.com です。
	// yourRegion を、バケットが配置されているリージョンの ID に置き換えます。 たとえば、バケットが China (Hangzhou) リージョンにある場合、リージョン ID は cn-hangzhou です。
	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
	clientOptions = append(clientOptions, oss.Region("yourRegion"))
	// 署名バージョンを設定します。
	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)
}

SDK 使用時の AccessDenied エラーのトラブルシューティング

AccessDenied エラーは、通常、権限が不足していることを示します。次の手順に従ってトラブルシューティングを行ってください。

1. AccessKey ID と AccessKey secret の確認：正しい AccessKey ID と AccessKey secret を使用していることを確認してください。

2. RAM ユーザーの権限の確認：RAM ユーザーに、バケットまたはオブジェクトの操作に必要な権限があるかどうかを確認してください。

3. バケットポリシーの確認：エラーメッセージに 「Access denied by bucket policy」 と記載されている場合は、バケットポリシーによってアクセスが拒否されています。

4. その他のエラータイプの照会方法や、一般的なアクセス制御エラーのトラブルシューティングについては、「エラー処理」をご参照ください。