Using libraries

Last change on 2025-06-05 • Created on 2024-11-20 • ID: ST-CAE3E

In general, all the AWS SDKs should work well with our Object Storage. Below, you can find a few examples for Python, Go and C#.

Please note that these recommendations are intended to help, but we cannot guarantee that everything will work as expected, and we do NOT provide support for them.

This article covers the following examples:

Python

Go

C#



For Python

AWS SDK for Python Boto3

official documentation

import logging
import random
import string
from boto3 import client
from botocore.client import Config

# Function to create a random hash
def random_hash(length=8):
    return ''.join(random.choices(string.ascii_lowercase + string.digits, k=length))

# Set variable with random hash
VAR_BUCKET_NAME = f"my-bucket-{random_hash()}"

# Create a new S3 client
s3 = client(
    "s3",
    region_name="fsn1",
    endpoint_url="https://fsn1.your-objectstorage.com",
    aws_access_key_id="YOUR_ACCESS_KEY",
    aws_secret_access_key="YOUR_SECRET_KEY",
    config=Config(
        signature_version='s3v4',
        s3={
            'payload_signing_enabled': False,
            'addressing_style': 'virtual',
        },
    )
)

# Create a new Bucket
s3.create_bucket(Bucket=VAR_BUCKET_NAME)

logging.info(f"Created Bucket: {VAR_BUCKET_NAME}")

# Upload a small object
s3.put_object(
    Bucket=VAR_BUCKET_NAME,
    Key="my-object",
    Body="""
# My object

This markdown document is the content of my object.
""",
)

logging.info("Created object")

For Go

MinIO Go Client SDK

official documentation

package main

import (
        "context"
        "crypto/rand"
        "encoding/hex"
        "fmt"
        "log"
        "strings"

        "github.com/minio/minio-go/v7"
        "github.com/minio/minio-go/v7/pkg/credentials"
)

// Generate a random hash
func generateRandomHash(length int) string {
        bytes := make([]byte, length)
        _, err := rand.Read(bytes)
        if err != nil {
                log.Fatalf("Failed to generate random hash: %v", err)
        }
        return hex.EncodeToString(bytes)[:length]
}

func main() {
        ctx := context.Background()

        // Set variable with random hash
        VAR_BUCKET_NAME := fmt.Sprintf("my-bucket-%s", generateRandomHash(8))

        // Create a new S3 client
        client, err := minio.New("fsn1.your-objectstorage.com", &minio.Options{
                Secure: true,
                Creds: credentials.NewStaticV4(
                        "YOUR-ACCESS-KEY",
                        "YOUR-SECRET-KEY",
                        "",
                ),
        })
        if err != nil {
                log.Fatal(err)
        }

        // Create a new Bucket
        err = client.MakeBucket(ctx, VAR_BUCKET_NAME, minio.MakeBucketOptions{Region: "fsn1"})
        if err != nil {
                log.Fatal(err)
        }

        log.Printf("Created Bucket: %s", VAR_BUCKET_NAME)

        // Upload a small object
        body := strings.NewReader(strings.TrimSpace(`
# My object

This markdown document is the content of my object.
`))

        _, err = client.PutObject(ctx,
                VAR_BUCKET_NAME,
                "my-object",
                body,
                body.Size(),
                minio.PutObjectOptions{},
        )
        if err != nil {
                log.Fatal(err)
        }

        log.Println("Created object")
}

AWS SDK for Go v2

official documentation

package main

import (
	"context"
	"crypto/rand"
	"encoding/hex"
	"fmt"
	"log"
	"strings"

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

// Generate a random hash
func generateRandomHash(length int) string {
        bytes := make([]byte, length)
        _, err := rand.Read(bytes)
        if err != nil {
                log.Fatalf("Failed to generate random hash: %v", err)
        }
        return hex.EncodeToString(bytes)[:length]
}

func main() {
	ctx := context.Background()

	// Set variable with random hash
	VAR_BUCKET_NAME := fmt.Sprintf("my-bucket-%s", generateRandomHash(8))

	// Create a new s3 client
	client := s3.New(s3.Options{
		AppID: "my-application/0.0.1",

		Region:       "fsn1",
		BaseEndpoint: aws.String("https://fsn1.your-objectstorage.com"),

		Credentials: credentials.StaticCredentialsProvider{Value: aws.Credentials{
			AccessKeyID:     "YOUR-ACCESS-KEY",
			SecretAccessKey: "YOUR-SECRET-KEY",
		}},
	})

	// Create a new Bucket
	_, err := client.CreateBucket(ctx, &s3.CreateBucketInput{
		Bucket: aws.String(VAR_BUCKET_NAME),
	})
	if err != nil {
		log.Fatal(err)
	}

	log.Printf("Created Bucket: %s", VAR_BUCKET_NAME)

	// Upload a small object
	body := strings.NewReader(strings.TrimSpace(`
# My object

This markdown document is the content of my object.
`))

	_, err = client.PutObject(ctx, &s3.PutObjectInput{
		Bucket:      aws.String(VAR_BUCKET_NAME),
		Key:         aws.String("my-object-e9be8f5c"),
		ContentType: aws.String("text/markdown"),

		Body: body,
	})
	if err != nil {
		log.Fatal(err)
	}

	log.Println("Created object")
}

For C#

AWS SDK for .NET

official documentation

using Amazon.S3;
using Amazon.S3.Model;

const string accessKey = "YOUR_ACCESS_KEY";
const string secretKey = "YOUR_SECRET_KEY";

// Generate a unique bucket name.
var bucketName = $"my-bucket-{Guid.NewGuid()}";

// Create a new S3 client.
var config = new AmazonS3Config
{
    ServiceURL = "https://fsn1.your-objectstorage.com",
    AuthenticationRegion = "fsn1",
    ForcePathStyle = false
};
var client = new AmazonS3Client(accessKey, secretKey, config);

// Create a new bucket.
var createBucket = new PutBucketRequest
{
    BucketName = bucketName,
    BucketRegionName = "fsn1"
};
await client.PutBucketAsync(createBucket);
Console.WriteLine($"Created bucket: {bucketName}");

// Upload a small object.
var createObject = new PutObjectRequest
{
    BucketName = bucketName,
    Key = "my-object",
    ContentBody = """
                  # My object

                  This markdown document is the content of my object.
                  """
};
await client.PutObjectAsync(createObject);
Console.WriteLine("Created object.");
Table of Contents