Skip to content
Console

Connect to S4 with the AWS SDK for Go v2

Connect to the S4 endpoint

The following code is based on these versions

github.com/aws/aws-sdk-go-v2 v1.24.1
github.com/aws/aws-sdk-go-v2/config v1.26.6
github.com/aws/aws-sdk-go-v2/credentials v1.16.16
github.com/aws/aws-sdk-go-v2/service/s3 v1.48.1
main.go
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/credentials"
	"github.com/aws/aws-sdk-go-v2/service/s3"
)

const s3Endpoint = "https://s3.bitiful.net"

func main() {
	// Replace with your own AccessKey and SecretKey
	s3AccessKey := "your-access-key"
	s3SecretKey := "your-secret-key"

	// Get the S3 client
	s3Client, err := getS3Client(s3AccessKey, s3SecretKey)
	if err != nil {
		log.Println("get s3 client failed, err=", err)
		return
	}
	log.Println("get s3 client success", s3Client)
}

// Get the S3 client
func getS3Client(key, secret string) (*s3.Client, error) {
	customResolver := aws.EndpointResolverWithOptionsFunc(func(service, region string, options ...interface{}) (aws.Endpoint, error) {
		if service == "S3" {
			return aws.Endpoint{
				URL: s3Endpoint,
			}, nil
		}
		return aws.Endpoint{}, fmt.Errorf("unknown service requested")
	})

	customProvider := credentials.NewStaticCredentialsProvider(key, secret, "")
	cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithCredentialsProvider(customProvider), config.WithEndpointResolverWithOptions(customResolver))
	if err != nil {
		return nil, err
	}
        cfg.Region = "cn-east-1"
	s3client := s3.NewFromConfig(cfg)
	return s3client, nil
}

List objects in a bucket

main.go
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/credentials"
	"github.com/aws/aws-sdk-go-v2/service/s3"
)

const s3Endpoint = "https://s3.bitiful.net"

func main() {
	// Replace with your own AccessKey and SecretKey
	s3AccessKey := "your-access-key"
	s3SecretKey := "your-secret-key"

	// Get the S3 client
	s3Client, err := getS3Client(s3AccessKey, s3SecretKey)
	if err != nil {
		log.Println("get s3 client failed, err=", err)
		return
	}

	// Replace with your own bucket name
	bucket := "your-bucket-name" // For example: test

	// List the objects in the bucket
	listObjsResponse, err := s3Client.ListObjectsV2(context.TODO(), &s3.ListObjectsV2Input{
		Bucket:    aws.String(bucket),
		Delimiter: aws.String("/"),
		MaxKeys:   aws.Int32(50),
	})
	if err != nil {
		log.Println("list objects failed, err=", err)
		return
	}

	// Print the object list
	for _, object := range listObjsResponse.Contents {
		log.Printf("object key=%v", *object.Key)
	}

	log.Println("list objects success")
}

// Get the S3 client
func getS3Client(key, secret string) (*s3.Client, error) {
	customResolver := aws.EndpointResolverWithOptionsFunc(func(service, region string, options ...interface{}) (aws.Endpoint, error) {
		if service == "S3" {
			return aws.Endpoint{
				URL: s3Endpoint,
			}, nil
		}
		return aws.Endpoint{}, fmt.Errorf("unknown service requested")
	})

	customProvider := credentials.NewStaticCredentialsProvider(key, secret, "")
	cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithCredentialsProvider(customProvider), config.WithEndpointResolverWithOptions(customResolver))
	if err != nil {
		return nil, err
	}
        cfg.Region = "cn-east-1"
	s3client := s3.NewFromConfig(cfg)
	return s3client, nil
}

Generate a time-limited presigned download URL

main.go
package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/credentials"
	"github.com/aws/aws-sdk-go-v2/service/s3"
)

const s3Endpoint = "https://s3.bitiful.net"

func main() {
	// Replace with your own AccessKey and SecretKey
	s3AccessKey := "your-access-key"
	s3SecretKey := "your-secret-key"

	// Get the S3 client
	s3Client, err := getS3Client(s3AccessKey, s3SecretKey)
	if err != nil {
		log.Println("get s3 client failed, err=", err)
		return
	}

	// Replace with your own bucket name and object key
	bucket := "your-bucket-name"   // For example: test
	objectKey := "your-object-key" // For example: test.txt

	// Get the presign client
	preSignClient := s3.NewPresignClient(s3Client)

	// Create the presigned request
	preSignedRequest, _ := preSignClient.PresignGetObject(context.TODO(), &s3.GetObjectInput{
		Bucket: aws.String(bucket),
		Key:    aws.String(objectKey),
	}, func(presignOptions *s3.PresignOptions) {
		presignOptions.Expires = time.Hour // Expiration time. The default is 900 seconds; set it to a suitable duration, such as 1 hour
	})

	// Print the presigned URL
	preSignedUrl := preSignedRequest.URL
	log.Printf("get preSigned url success, preSignedUrl=%v", preSignedUrl)
}

// Get the S3 client
func getS3Client(key, secret string) (*s3.Client, error) {
	customResolver := aws.EndpointResolverWithOptionsFunc(func(service, region string, options ...interface{}) (aws.Endpoint, error) {
		if service == "S3" {
			return aws.Endpoint{
				URL: s3Endpoint,
			}, nil
		}
		return aws.Endpoint{}, fmt.Errorf("unknown service requested")
	})

	customProvider := credentials.NewStaticCredentialsProvider(key, secret, "")
	cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithCredentialsProvider(customProvider), config.WithEndpointResolverWithOptions(customResolver))
	if err != nil {
		return nil, err
	}
        cfg.Region = "cn-east-1"
	s3client := s3.NewFromConfig(cfg)
	return s3client, nil
}

Add CoreIX media processing parameters to a presigned URL

S3 presigning includes all URL query parameters (args) in the signature, so you need to use middleware here:

main.go
package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"github.com/aws/smithy-go/middleware"
	smithyhttp "github.com/aws/smithy-go/transport/http"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/credentials"
	"github.com/aws/aws-sdk-go-v2/service/s3"
)

const s3Endpoint = "https://s3.bitiful.net"

func main() {
	// Replace with your own AccessKey and SecretKey
	s3AccessKey := "your-access-key"
	s3SecretKey := "your-secret-key"

	// Get the S3 client
	s3Client, err := getS3Client(s3AccessKey, s3SecretKey)
	if err != nil {
		log.Println("get s3 client failed, err=", err)
		return
	}

	// Replace with your own bucket name and object key
	bucket := "your-bucket-name"   // For example: test
	objectKey := "your-object-key" // For example: test.txt

	// Get the presign client
	preSignClient := s3.NewPresignClient(s3Client)

	// Add CoreIX media processing parameters to the presigned URL
	bitifulQuery := map[string]string{"w": "500"} // Width of 500px
	// Add the per-connection rate limit parameter to the presigned URL
	// bitifulQuery := map[string]string{"x-amz-limit-rate": "102400"} // 102400 means 102400 bytes/second

	//Custom parameters, passed via ctx
	ctx := context.WithValue(context.TODO(), "bitiful-query", bitifulQuery)

	// Create the presigned request
	preSignedRequest, _ := preSignClient.PresignGetObject(ctx, &s3.GetObjectInput{
		Bucket: aws.String(bucket),
		Key:    aws.String(objectKey),
	}, func(presignOptions *s3.PresignOptions) {
		presignOptions.Expires = time.Hour // Expiration time. The default is 900 seconds; set it to a suitable duration, such as 1 hour
		presignOptions.ClientOptions = append(presignOptions.ClientOptions, func(options *s3.Options) {
			// Inject the custom middleware
			options.APIOptions = append(options.APIOptions, registerPresignedUrlAddBitifulQueryMiddleware)
		})
	})

	//Print the presigned URL
	preSignedUrl := preSignedRequest.URL
	log.Println("get preSigned url success, preSignedUrl=", preSignedUrl)
}

// Get the S3 client
func getS3Client(key, secret string) (*s3.Client, error) {
	customResolver := aws.EndpointResolverWithOptionsFunc(func(service, region string, options ...interface{}) (aws.Endpoint, error) {
		if service == "S3" {
			return aws.Endpoint{
				URL: s3Endpoint,
			}, nil
		}
		return aws.Endpoint{}, fmt.Errorf("unknown service requested")
	})

	customProvider := credentials.NewStaticCredentialsProvider(key, secret, "")
	cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithCredentialsProvider(customProvider), config.WithEndpointResolverWithOptions(customResolver))
	if err != nil {
		return nil, err
	}
        cfg.Region = "cn-east-1"
	s3client := s3.NewFromConfig(cfg)
	return s3client, nil
}

// Add custom parameters to the presigned URL
func registerPresignedUrlAddBitifulQueryMiddleware(stack *middleware.Stack) error {
	// Attach the custom middleware to the beginning of the Initialize step
	return stack.Build.Add(presignedUrlAddBitifulQueryMiddleware, middleware.After)
}

// Custom middleware
var presignedUrlAddBitifulQueryMiddleware = middleware.BuildMiddlewareFunc("AddBitifulQuery", func(ctx context.Context, input middleware.BuildInput, next middleware.BuildHandler) (out middleware.BuildOutput, metadata middleware.Metadata, err error) {
	bitifulQuery := ctx.Value("bitiful-query")
	if bitifulQuery == nil {
		return next.HandleBuild(ctx, input)
	}

	req, ok := input.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, fmt.Errorf("unknown transport type %T", req)
	}

	bitifulQueryMap, ok := bitifulQuery.(map[string]string)
	if !ok {
		return next.HandleBuild(ctx, input)
	}

	// set bitiful query
	query := req.URL.Query()
	for key, value := range bitifulQueryMap {
		query.Set(key, value)
	}
	req.URL.RawQuery = query.Encode()

	return next.HandleBuild(ctx, input)
})

Add a per-connection rate limit parameter to a presigned URL

S4 extends S3 with the x-amz-limit-rate parameter, which limits the download speed of each connection for the object. The value is in bytes (a positive integer).

As above, you still need middleware to handle the signature. Follow "Add CoreIX media processing parameters to a presigned URL" and change only bitifulQuery:

...
// Add the per-connection rate limit parameter to the presigned URL
bitifulQuery := map[string]string{"x-amz-limit-rate": "102400"} // 102400 means 102400 bytes/second

//Custom parameters, passed via ctx
ctx := context.WithValue(context.TODO(), "bitiful-query", bitifulQuery)
...