Go | Tigris Object Storage Documentation

There are two ways to use Tigris with Go:

• AWS Go SDK — use the standard AWS SDK for Go v2, just point it at Tigris. This is the recommended approach for production use.
• Tigris Go SDK — a Go SDK with Tigris-specific features like snapshots and bucket forking built in. Currently in development.

Both are fully S3-compatible. We recommend the AWS Go SDK for most use cases today.

Prerequisites

• Go 1.21+
• A Tigris account — create one at storage.new
• An access key from console.storage.dev/createaccesskey

Install

• AWS Go SDK
• Tigris Go SDK

go get github.com/aws/aws-sdk-go-v2

go get github.com/aws/aws-sdk-go-v2/config

go get github.com/aws/aws-sdk-go-v2/service/s3

go get github.com/tigrisdata/storage-go

Configure credentials

Set your Tigris credentials as environment variables:

export AWS_ACCESS_KEY_ID="tid_your_access_key"

export AWS_SECRET_ACCESS_KEY="tsec_your_secret_key"

export AWS_ENDPOINT_URL="https://t3.storage.dev"

export AWS_REGION="auto"

Create a client

• AWS Go SDK
• Tigris Go SDK

package main

import (
    "context"
    "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() {
    ctx := context.Background()
    sdkConfig, err := config.LoadDefaultConfig(ctx)
    if err != nil {
        log.Fatal(err)
    }
    client := s3.NewFromConfig(sdkConfig, func(o *s3.Options) {
        o.BaseEndpoint = aws.String("https://t3.storage.dev")
        o.Region = "auto"
        o.UsePathStyle = false
    })
}

If you set AWS_ENDPOINT_URL in your environment, you can omit the BaseEndpoint option.

package main

import (
    "context"
    "log"
    storage "github.com/tigrisdata/storage-go"
)

func main() {
    ctx := context.Background()
    client, err := storage.New(ctx)
    if err != nil {
        log.Fatal(err)
    }
}

The SDK reads credentials from environment variables automatically. You can also configure it with options:

client, err := storage.New(ctx,
    storage.WithGlobalEndpoint(),
    storage.WithAccessKeypair("tid_your_access_key", "tsec_your_secret_key"),
)

Basic operations

• AWS Go SDK
• Tigris Go SDK

Create a bucket

_, err := client.CreateBucket(ctx, &s3.CreateBucketInput{
    Bucket: aws.String("my-bucket"),
})

Upload an object

import "strings"
_, err := client.PutObject(ctx, &s3.PutObjectInput{
    Bucket: aws.String("my-bucket"),
    Key:    aws.String("hello.txt"),
    Body:   strings.NewReader("Hello, World!"),
})

Download an object

import "io"
result, err := client.GetObject(ctx, &s3.GetObjectInput{
    Bucket: aws.String("my-bucket"),
    Key:    aws.String("hello.txt"),
})
if err != nil {
    log.Fatal(err)
}
defer result.Body.Close()
data, _ := io.ReadAll(result.Body)
fmt.Println(string(data))

List objects

result, err := client.ListObjectsV2(ctx, &s3.ListObjectsV2Input{
    Bucket: aws.String("my-bucket"),
})
if err != nil {
    log.Fatal(err)
}
for _, obj := range result.Contents {
    fmt.Printf("  %s  (%d bytes)\n", *obj.Key, *obj.Size)
}

Generate a presigned URL

import "github.com/aws/aws-sdk-go-v2/service/s3"
presigner := s3.NewPresignClient(client)
req, err := presigner.PresignGetObject(ctx, &s3.GetObjectInput{
    Bucket: aws.String("my-bucket"),
    Key:    aws.String("hello.txt"),
}, s3.WithPresignExpires(time.Hour))
if err != nil {
    log.Fatal(err)
}
fmt.Println(req.URL)

The Tigris Go SDK wraps the AWS SDK, so standard S3 operations work the same way. Use client.S3 to access the underlying S3 client:

Create a bucket

_, err := client.S3.CreateBucket(ctx, &s3.CreateBucketInput{
    Bucket: aws.String("my-bucket"),
})

Upload an object

import "strings"
_, err := client.S3.PutObject(ctx, &s3.PutObjectInput{
    Bucket: aws.String("my-bucket"),
    Key:    aws.String("hello.txt"),
    Body:   strings.NewReader("Hello, World!"),
})

Download an object

import "io"
result, err := client.S3.GetObject(ctx, &s3.GetObjectInput{
    Bucket: aws.String("my-bucket"),
    Key:    aws.String("hello.txt"),
})
if err != nil {
    log.Fatal(err)
}
defer result.Body.Close()
data, _ := io.ReadAll(result.Body)
fmt.Println(string(data))

List objects

result, err := client.S3.ListObjectsV2(ctx, &s3.ListObjectsV2Input{
    Bucket: aws.String("my-bucket"),
})
if err != nil {
    log.Fatal(err)
}
for _, obj := range result.Contents {
    fmt.Printf("  %s  (%d bytes)\n", *obj.Key, *obj.Size)
}

Snapshots and forks

The Tigris Go SDK provides built-in support for snapshots and bucket forking. You can also use these features with the AWS Go SDK by passing Tigris-specific headers on each request, but the Tigris Go SDK handles this for you automatically.

import storage "github.com/tigrisdata/storage-go"

// Create a snapshot-enabled bucket
err := client.CreateSnapshotBucket(ctx, "my-snapshots")
// Take a snapshot
snapshot, err := client.CreateSnapshot(ctx, "my-snapshots")
fmt.Printf("Snapshot: %s\n", snapshot)
// List snapshots
snapshots, err := client.ListSnapshots(ctx, "my-snapshots")
// Fork a bucket — instant copy-on-write clone
err = client.CreateFork(ctx, "my-snapshots", "experiment-1")

Next steps

• Example Go app — a simple web app that uploads and manages files with Tigris, ready to deploy to Fly.io
• AWS Go SDK reference — advanced usage with presigned URLs, conditional operations, metadata queries, and object notifications
• Snapshots and forks — full guide on Tigris snapshot and fork concepts
• storage-go on GitHub — Tigris Go SDK source code