---
title: "AWS SDK for Go (Golang) With Wasabi"
slug: "how-do-i-use-aws-sdk-for-go-golang-with-wasabi"
updated: 2026-05-28T15:57:00Z
published: 2026-05-28T15:57:00Z
---

> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wasabi.com/llms.txt
> Use this file to discover all available pages before exploring further.

# AWS SDK for Go (Golang) With Wasabi

[AWS SDK for GO](https://aws.amazon.com/sdk-for-go/) has been certified for use with Wasabi.

## Using the GO SDK

Execute the following steps:

1. Install the [AWS SDK for GO](https://aws.amazon.com/sdk-for-go/).
2. (Optional) Configure an additional [AWS CLI profile for Wasabi](https://docs.wasabi.com/docs/how-do-i-use-aws-cli-with-wasabi) account using the Wasabi keys.

In this example, we set the profile name as "wasabi" in the "~/.aws/credentials" file. To help you use this SDK with Wasabi, we provided examples for both IAM and S3:

- Connecting to IAM and S3 Endpoints
- Creating a User Using IAM
- Creating a Bucket
- Uploading an Object to the Bucket
- Reading an Object From the Bucket
- Deleting an Object From the Bucket

Additional examples are available from the [AWS documentation](https://docs.aws.amazon.com/aws-sdk-php/v2/guide/).

> [!NOTE]
> The examples use Wasabi's us-east-1 storage region. For other Wasabi storage regions, use the appropriate [Wasabi service URL](https://docs.wasabi.com/docs/what-are-the-service-urls-for-wasabis-different-storage-regions).

> [!NOTE]
> Send all IAM requests to [iam.wasabisys.com](http://sts.wasabisys.com/).

## Connecting to IAM and S3 Endpoints

#### IAM

```plaintext
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/service/iam"
)

func main() {
cfg, err := config.LoadDefaultConfig(context.TODO(),
config.WithRegion("us-east-1"),
config.WithEndpointResolverWithOptions(
aws.EndpointResolverWithOptionsFunc(
func(service, region string, options ...interface{}) (aws.Endpoint, error) {
if service == iam.ServiceID {
return aws.Endpoint{
URL: "https://iam.wasabisys.com",
SigningRegion: "us-east-1",
}, nil
}
return aws.Endpoint{}, &aws.EndpointNotFoundError{}
},
),
),
)
if err != nil {
log.Fatalf("unable to load SDK config, %v", err)
}

iamClient := iam.NewFromConfig(cfg)

_, err = iamClient.ListUsers(context.TODO(), &iam.ListUsersInput{})
if err != nil {
log.Fatalf("unable to list IAM users, %v", err)
}

fmt.Println("Successfully connected to IAM service")
} }
```

#### S3

```plaintext
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/service/s3"
)

func main() {
cfg, err := config.LoadDefaultConfig(context.TODO(),
config.WithRegion("us-east-1"),
config.WithEndpointResolverWithOptions(
aws.EndpointResolverWithOptionsFunc(
func(service, region string, options ...interface{}) (aws.Endpoint, error) {
if service == s3.ServiceID {
return aws.Endpoint{
URL: "https://s3.wasabisys.com",
SigningRegion: "us-east-1",
}, nil
}
return aws.Endpoint{}, &aws.EndpointNotFoundError{}
},
),
),
)
if err != nil {
log.Fatalf("unable to load SDK config, %v", err)
}

s3Client := s3.NewFromConfig(cfg)

_, err = s3Client.ListBuckets(context.TODO(), &s3.ListBucketsInput{})
if err != nil {
log.Fatalf("unable to list S3 buckets, %v", err)
}

fmt.Println("Successfully connected to S3 service")
}
```

## Creating a User Using IAM

```plaintext
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/service/iam"
)

func main() {
cfg, err := config.LoadDefaultConfig(context.TODO(),
config.WithRegion("us-east-1"),
config.WithEndpointResolverWithOptions(
aws.EndpointResolverWithOptionsFunc(
func(service, region string, options ...interface{}) (aws.Endpoint, error) {
if service == iam.ServiceID {
return aws.Endpoint{
URL: "https://iam.wasabisys.com",
SigningRegion: "us-east-1",
}, nil
}
return aws.Endpoint{}, &aws.EndpointNotFoundError{}
},
),
),
)
if err != nil {
log.Fatalf("unable to load SDK config, %v", err)
}

iamClient := iam.NewFromConfig(cfg)

userName := "iam-user-name"

createUserOutput, err := iamClient.CreateUser(context.TODO(), &iam.CreateUserInput{
UserName: &userName,
})
if err != nil {
log.Fatalf("Unable to create IAM user: %v", err)
}

fmt.Printf("Created user: %s\n", aws.ToString(createUserOutput.User.UserName))
}
```

## Creating a Bucket

```plaintext
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/service/s3" )

func main() {
cfg, err := config.LoadDefaultConfig(context.TODO(),
config.WithRegion("us-east-1"),
config.WithEndpointResolverWithOptions(
aws.EndpointResolverWithOptionsFunc(
func(service, region string, options ...interface{}) (aws.Endpoint, error) {
if service == s3.ServiceID {
return aws.Endpoint{
URL: "https://s3.wasabisys.com",
SigningRegion: "us-east-1",
}, nil
}
return aws.Endpoint{}, &aws.EndpointNotFoundError{}
},
),
),
)
if err != nil {
log.Fatalf("Unable to load SDK config, %v", err)
}

s3Client := s3.NewFromConfig(cfg)

bucketName := "bucket-name"

_, err = s3Client.CreateBucket(context.TODO(), &s3.CreateBucketInput{
Bucket: &bucketName,
})
if err != nil {
log.Fatalf("Unable to create bucket: %v", err)
}

fmt.Printf("Bucket %s created successfully\n", bucketName)
}
```

## Uploading an Object to the Bucket

```plaintext
package main

import (
"context"
"fmt"
"os"
"path/filepath"

"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/feature/s3/manager"
"github.com/aws/aws-sdk-go-v2/service/s3" )

func main() {
accessKeyID := "id"
secretAccessKey := "key"

cfg, err := config.LoadDefaultConfig(context.TODO(),
config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(accessKeyID, secretAccessKey, "")),
config.WithRegion("us-east-1"),
config.WithEndpointResolverWithOptions(
aws.EndpointResolverWithOptionsFunc(
func(service, region string, options ...interface{}) (aws.Endpoint, error) {
if service == s3.ServiceID {
return aws.Endpoint{
URL: "https://s3.wasabisys.com",
SigningRegion: "us-east-1",
}, nil
}
return aws.Endpoint{}, &aws.EndpointNotFoundError{}
},
),
),
)
if err != nil {
fmt.Println("Configuration error:", err)
return
}

client := s3.NewFromConfig(cfg)

filename := "file name with path"

file, err := os.Open(filename)
if err != nil {
fmt.Println("Error opening file:", err)
return
}
defer file.Close()

uploader := manager.NewUploader(client)

result, err := uploader.Upload(context.TODO(), &s3.PutObjectInput{
Bucket: aws.String("bucket-name"),
Key: aws.String(filepath.Base(filename)),
Body: file,
})
if err != nil {
fmt.Println("Error uploading file:", err)
return
}

fmt.Printf("File uploaded successfully: %s\n", result.Location)
}
```

## Reading an Object From the Bucket

```plaintext
package main

import (
"context"
"fmt"
"io/ioutil" "log"

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

func main() {
cfg, err := config.LoadDefaultConfig(context.TODO(),
config.WithRegion("us-east-1"),
config.WithEndpointResolverWithOptions(
aws.EndpointResolverWithOptionsFunc(
func(service, region string, options ...interface{}) (aws.Endpoint, error) {
if service == s3.ServiceID {
return aws.Endpoint{
URL: "https://s3.wasabisys.com",
SigningRegion: "us-east-1",
}, nil
}
return aws.Endpoint{}, &aws.EndpointNotFoundError{}
},
),
),
)
if err != nil {
log.Fatalf("Unable to load SDK config, %v", err)
}

s3Client := s3.NewFromConfig(cfg)

bucketName := "bucket-name"
objectKey := "object name with prefix"

getObjectOutput, err := s3Client.GetObject(context.TODO(), &s3.GetObjectInput{
Bucket: &bucketName,
Key: &objectKey,
})
if err != nil {
log.Fatalf("Unable to get object: %v", err)
}

body, err := ioutil.ReadAll(getObjectOutput.Body)
if err != nil {
log.Fatalf("Unable to read object body: %v", err)
}
defer getObjectOutput.Body.Close()

fmt.Printf("Object content: %s\n", string(body))
}
```

## Deleting an Object From the Bucket

```plaintext
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/service/s3" )

func main() {
cfg, err := config.LoadDefaultConfig(context.TODO(),
config.WithRegion("us-east-1"),
config.WithEndpointResolverWithOptions(
aws.EndpointResolverWithOptionsFunc(
func(service, region string, options ...interface{}) (aws.Endpoint, error) {
if service == s3.ServiceID {
return aws.Endpoint{
URL: "https://s3.wasabisys.com",
SigningRegion: "us-east-1",
}, nil
}
return aws.Endpoint{}, &aws.EndpointNotFoundError{}
},
),
),
)
if err != nil { log.Fatalf("Unable to load SDK config, %v", err)
}

s3Client := s3.NewFromConfig(cfg)

bucketName := "bucket-name"
objectKey := "Object name with prefix"

_, err = s3Client.DeleteObject(context.TODO(), &s3.DeleteObjectInput{
Bucket: &bucketName,
Key: &objectKey,
})
if err != nil {
log.Fatalf("Unable to delete object: %v", err)
}

fmt.Printf("Object '%s' deleted successfully from bucket '%s'\n", objectKey, bucketName)
}
```