MinIO Go Client API Reference

// Create a bucket at region 'us-east-1' with object locking enabled.
err = minioClient.MakeBucket(context.Background(), "mybucket", minio.MakeBucketOptions{Region: "us-east-1", ObjectLocking: true})
if err != nil {
	fmt.Println(err)
	return
}
fmt.Println("Successfully created mybucket.")

buckets, err := minioClient.ListBuckets(context.Background())
if err != nil {
	fmt.Println(err)
	return
}
for _, bucket := range buckets {
	fmt.Println(bucket)
}

found, err := minioClient.BucketExists(context.Background(), "mybucket")
if err != nil {
	fmt.Println(err)
	return
}
if found {
	fmt.Println("Bucket found")
}

err = minioClient.RemoveBucket(context.Background(), "mybucket")
if err != nil {
	fmt.Println(err)
	return
}

ctx, cancel := context.WithCancel(context.Background())

defer cancel()

objectCh := minioClient.ListObjects(ctx, "mybucket", minio.ListObjectsOptions{
	Prefix:    "myprefix",
	Recursive: true,
})
for object := range objectCh {
	if object.Err != nil {
		fmt.Println(object.Err)
		return
	}
	fmt.Println(object)
}

opts := minio.ListObjectsOptions{
	Prefix:    "myprefix",
	Recursive: true,
}

for object := range minioClient.ListObjectsIter(context.Background(), "mybucket", opts) {
	if object.Err != nil {
		fmt.Println(object.Err)
		return
	}
	fmt.Println(object.Key, object.Size)
}

isRecursive := true // Recursively list everything at 'myprefix'
multiPartObjectCh := minioClient.ListIncompleteUploads(context.Background(), "mybucket", "myprefix", isRecursive)
for multiPartObject := range multiPartObjectCh {
	if multiPartObject.Err != nil {
		fmt.Println(multiPartObject.Err)
		return
	}
	fmt.Println(multiPartObject)
}

// Create tags from a map.
tags, err := tags.NewTags(map[string]string{
	"Tag1": "Value1",
	"Tag2": "Value2",
}, false)
if err != nil {
	log.Fatalln(err)
}

err = minioClient.SetBucketTagging(context.Background(), "my-bucketname", tags)
if err != nil {
	log.Fatalln(err)
}

tags, err := minioClient.GetBucketTagging(context.Background(), "my-bucketname")
if err != nil {
	log.Fatalln(err)
}

fmt.Printf("Fetched Object Tags: %v\n", tags)

err := minioClient.RemoveBucketTagging(context.Background(), "my-bucketname")
if err != nil {
	log.Fatalln(err)
}

opt := minio.AppendObjectOptions{}
info, err := minio.AppendObject(context.Background(), "my-bucket-name", "my-object-name", my_progress_reader, size, opt)
if err != nil {
	log.Fatalln(err)
}

object, err := minioClient.GetObject(context.Background(), "mybucket", "myobject", minio.GetObjectOptions{})
if err != nil {
	fmt.Println(err)
	return
}
defer object.Close()

localFile, err := os.Create("/tmp/local-file.jpg")
if err != nil {
	fmt.Println(err)
	return
}
defer localFile.Close()

if _, err = io.Copy(localFile, object); err != nil {
	fmt.Println(err)
	return
}

err = minioClient.FGetObject(context.Background(), "mybucket", "myobject", "/tmp/myobject", minio.GetObjectOptions{})
if err != nil {
	fmt.Println(err)
	return
}

file, err := os.Open("my-testfile")
if err != nil {
	fmt.Println(err)
	return
}
defer file.Close()

fileStat, err := file.Stat()
if err != nil {
	fmt.Println(err)
	return
}

uploadInfo, err := minioClient.PutObject(context.Background(), "mybucket", "myobject", file, fileStat.Size(), minio.PutObjectOptions{ContentType: "application/octet-stream"})
if err != nil {
	fmt.Println(err)
	return
}
fmt.Println("Successfully uploaded bytes: ", uploadInfo)

// Use-case 1: Simple copy object with no conditions.
// Source object
srcOpts := minio.CopySrcOptions{
	Bucket: "my-sourcebucketname",
	Object: "my-sourceobjectname",
}

// Destination object
dstOpts := minio.CopyDestOptions{
	Bucket: "my-bucketname",
	Object: "my-objectname",
}

// Copy object call
uploadInfo, err := minioClient.CopyObject(context.Background(), dstOpts, srcOpts)
if err != nil {
	fmt.Println(err)
	return
}

fmt.Println("Successfully copied object:", uploadInfo)

// Use-case 2:
// Copy object with copy-conditions, and copying only part of the source object.
// 1. that matches a given ETag
// 2. and modified after 1st April 2014
// 3. but unmodified since 23rd April 2014
// 4. copy only first 1MiB of object.

// Source object
srcOpts := minio.CopySrcOptions{
	Bucket:               "my-sourcebucketname",
	Object:               "my-sourceobjectname",
	MatchETag:            "31624deb84149d2f8ef9c385918b653a",
	MatchModifiedSince:   time.Date(2014, time.April, 1, 0, 0, 0, 0, time.UTC),
	MatchUnmodifiedSince: time.Date(2014, time.April, 23, 0, 0, 0, 0, time.UTC),
	Start:                0,
	End:                  1024*1024 - 1,
}

// Destination object
dstOpts := minio.CopyDestOptions{
	Bucket: "my-bucketname",
	Object: "my-objectname",
}

// Copy object call
_, err = minioClient.CopyObject(context.Background(), dstOpts, srcOpts)
if err != nil {
	fmt.Println(err)
	return
}

fmt.Println("Successfully copied object:", uploadInfo)

// Prepare source decryption key (here we assume same key to
// decrypt all source objects.)
sseSrc := encrypt.DefaultPBKDF([]byte("password"), []byte("salt"))

// Source objects to concatenate. We also specify decryption
// key for each
src1Opts := minio.CopySrcOptions{
	Bucket:     "bucket1",
	Object:     "object1",
	Encryption: sseSrc,
	MatchETag:  "31624deb84149d2f8ef9c385918b653a",
}

src2Opts := minio.CopySrcOptions{
	Bucket:     "bucket2",
	Object:     "object2",
	Encryption: sseSrc,
	MatchETag:  "f8ef9c385918b653a31624deb84149d2",
}

src3Opts := minio.CopySrcOptions{
	Bucket:     "bucket3",
	Object:     "object3",
	Encryption: sseSrc,
	MatchETag:  "5918b653a31624deb84149d2f8ef9c38",
}

// Prepare destination encryption key
sseDst := encrypt.DefaultPBKDF([]byte("new-password"), []byte("new-salt"))

// Create destination info
dstOpts := CopyDestOptions{
	Bucket:     "bucket",
	Object:     "object",
	Encryption: sseDst,
}

// Compose object call by concatenating multiple source files.
uploadInfo, err := minioClient.ComposeObject(context.Background(), dst, srcs...)
if err != nil {
	fmt.Println(err)
	return
}

fmt.Println("Composed object successfully:", uploadInfo)

uploadInfo, err := minioClient.FPutObject(context.Background(), "my-bucketname", "my-objectname", "my-filename.csv", minio.PutObjectOptions{
	ContentType: "application/csv",
})
if err != nil {
	fmt.Println(err)
	return
}
fmt.Println("Successfully uploaded object: ", uploadInfo)

objInfo, err := minioClient.StatObject(context.Background(), "mybucket", "myobject", minio.StatObjectOptions{})
if err != nil {
	fmt.Println(err)
	return
}
fmt.Println(objInfo)

opts := minio.RemoveObjectOptions{
	GovernanceBypass: true,
	VersionID:        "myversionid",
}
err = minioClient.RemoveObject(context.Background(), "mybucket", "myobject", opts)
if err != nil {
	fmt.Println(err)
	return
}

objectsCh := make(chan minio.ObjectInfo)

// Send object names that are needed to be removed to objectsCh
go func() {
	defer close(objectsCh)
	// List all objects from a bucket-name with a matching prefix.
	for object := range minioClient.ListObjects(context.Background(), "my-bucketname", "my-prefixname", true, nil) {
		if object.Err != nil {
			log.Fatalln(object.Err)
		}
		objectsCh <- object
	}
}()

opts := minio.RemoveObjectsOptions{
	GovernanceBypass: true,
}

for rErr := range minioClient.RemoveObjects(context.Background(), "my-bucketname", objectsCh, opts) {
	fmt.Println("Error detected during deletion: ", rErr)
}

objectsCh := make(chan minio.ObjectInfo)

go func() {
	defer close(objectsCh)
	for object := range minioClient.ListObjects(context.Background(), "my-bucketname", minio.ListObjectsOptions{Prefix: "my-prefixname", Recursive: true}) {
		if object.Err != nil {
			log.Fatalln(object.Err)
		}
		objectsCh <- object
	}
}()

opts := minio.RemoveObjectsOptions{
	GovernanceBypass: true,
}

successCount := 0
errorCount := 0
for result := range minioClient.RemoveObjectsWithResult(context.Background(), "my-bucketname", objectsCh, opts) {
	if result.Err != nil {
		fmt.Printf("Error deleting %s: %v\n", result.ObjectName, result.Err)
		errorCount++
	} else {
		fmt.Printf("Successfully deleted %s\n", result.ObjectName)
		successCount++
	}
}
fmt.Printf("Deleted: %d, Errors: %d\n", successCount, errorCount)

opts := minio.ListObjectsOptions{
	Prefix:    "my-prefixname",
	Recursive: true,
}

removeOpts := minio.RemoveObjectsOptions{
	GovernanceBypass: true,
}

for err := range minioClient.RemoveObjectsWithIter(context.Background(), "my-bucketname", minioClient.ListObjectsIter(context.Background(), "my-bucketname", opts), removeOpts) {
	fmt.Printf("Error detected during deletion: %v\n", err)
}

mode, retainUntilDate, err := minioClient.GetObjectRetention(context.Background(), "mybucket", "myobject", "")
if err != nil {
	fmt.Println(err)
	return
}
fmt.Printf("Retention mode: %v, Retain until: %v\n", mode, retainUntilDate)

s := minio.LegalHoldEnabled
opts := minio.PutObjectLegalHoldOptions{
	Status: &s,
}
err = minioClient.PutObjectLegalHold(context.Background(), "mybucket", "myobject", opts)
if err != nil {
	fmt.Println(err)
	return
}

opts := minio.GetObjectLegalHoldOptions{}
err = minioClient.GetObjectLegalHold(context.Background(), "mybucket", "myobject", opts)
if err != nil {
	fmt.Println(err)
	return
}

	// Initialize minio client object.
	minioClient, err := minio.New(endpoint, &minio.Options{
		Creds:  credentials.NewStaticV4(accessKeyID, secretAccessKey, ""),
		Secure: useSSL,
	})

	opts := minio.SelectObjectOptions{
		Expression:     "select count(*) from s3object",
		ExpressionType: minio.QueryExpressionTypeSQL,
		InputSerialization: minio.SelectObjectInputSerialization{
			CompressionType: minio.SelectCompressionNONE,
			CSV: &minio.CSVInputOptions{
				FileHeaderInfo:  minio.CSVFileHeaderInfoNone,
				RecordDelimiter: "\n",
				FieldDelimiter:  ",",
			},
		},
		OutputSerialization: minio.SelectObjectOutputSerialization{
			CSV: &minio.CSVOutputOptions{
				RecordDelimiter: "\n",
				FieldDelimiter:  ",",
			},
		},
	}

	reader, err := s3Client.SelectObjectContent(context.Background(), "mycsvbucket", "mycsv.csv", opts)
	if err != nil {
		log.Fatalln(err)
	}
	defer reader.Close()

	if _, err := io.Copy(os.Stdout, reader); err != nil {
		log.Fatalln(err)
	}

err = minioClient.PutObjectTagging(context.Background(), bucketName, objectName, objectTags)
if err != nil {
	fmt.Println(err)
	return
}

tags, err = minioClient.GetObjectTagging(context.Background(), bucketName, objectName)
if err != nil {
	fmt.Println(err)
	return
}
fmt.Printf("Fetched Tags: %s", tags)

err = minioClient.RemoveObjectTagging(context.Background(), bucketName, objectName)
if err != nil {
	fmt.Println(err)
	return
}

opts := minio.RestoreRequest{}
opts.SetDays(1)
opts.SetGlacierJobParameters(minio.GlacierJobParameters{Tier: minio.TierStandard})

err = s3Client.RestoreObject(context.Background(), "your-bucket", "your-object", "", opts)
if err != nil {
	log.Fatalln(err)
}

objectAttributes, err := c.GetObjectAttributes(
	context.Background(),
	"your-bucket",
	"your-object",
	minio.ObjectAttributesOptions{
		VersionID:      "object-version-id",
		NextPartMarker: 0,
		MaxParts:       100,
	})

if err != nil {
	fmt.Println(err)
	return
}

fmt.Println(objectAttributes)

err = minioClient.RemoveIncompleteUpload(context.Background(), "mybucket", "myobject")
if err != nil {
	fmt.Println(err)
	return
}

// Set request parameters for content-disposition.
reqParams := make(url.Values)
reqParams.Set("response-content-disposition", "attachment; filename=\"your-filename.txt\"")

// Generates a presigned url which expires in a day.
presignedURL, err := minioClient.PresignedGetObject(context.Background(), "mybucket", "myobject", time.Second*24*60*60, reqParams)
if err != nil {
	fmt.Println(err)
	return
}
fmt.Println("Successfully generated presigned URL", presignedURL)

// Generates a url which expires in a day.
expiry := time.Second * 24 * 60 * 60 // 1 day.
presignedURL, err := minioClient.PresignedPutObject(context.Background(), "mybucket", "myobject", expiry)
if err != nil {
	fmt.Println(err)
	return
}
fmt.Println("Successfully generated presigned URL", presignedURL)

// Set request parameters for content-disposition.
reqParams := make(url.Values)
reqParams.Set("response-content-disposition", "attachment; filename=\"your-filename.txt\"")

// Generates a presigned url which expires in a day.
presignedURL, err := minioClient.PresignedHeadObject(context.Background(), "mybucket", "myobject", time.Second*24*60*60, reqParams)
if err != nil {
	fmt.Println(err)
	return
}
fmt.Println("Successfully generated presigned URL", presignedURL)

// Initialize policy condition config.
policy := minio.NewPostPolicy()

// Apply upload policy restrictions:
policy.SetBucket("mybucket")
policy.SetKey("myobject")
policy.SetExpires(time.Now().UTC().AddDate(0, 0, 10)) // expires in 10 days

// Only allow 'png' images.
policy.SetContentType("image/png")

// Only allow content size in range 1KB to 1MB.
policy.SetContentLengthRange(1024, 1024*1024)

// Add a user metadata using the key "custom" and value "user"
policy.SetUserMetadata("custom", "user")

// Get the POST form key/value object:
url, formData, err := minioClient.PresignedPostPolicy(context.Background(), policy)
if err != nil {
	fmt.Println(err)
	return
}

// POST your content from the command line using `curl`
fmt.Printf("curl ")
for k, v := range formData {
	fmt.Printf("-F %s=%s ", k, v)
}
fmt.Printf("-F file=@/etc/bash.bashrc ")
fmt.Printf("%s\n", url)

policy := `{"Version": "2012-10-17","Statement": [{"Action": ["s3:GetObject"],"Effect": "Allow","Principal": {"AWS": ["*"]},"Resource": ["arn:aws:s3:::my-bucketname/*"],"Sid": ""}]}`

err = minioClient.SetBucketPolicy(context.Background(), "my-bucketname", policy)
if err != nil {
	fmt.Println(err)
	return
}

policy, err := minioClient.GetBucketPolicy(context.Background(), "my-bucketname")
if err != nil {
	log.Fatalln(err)
}