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.1package 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
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
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:
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)
...