MinIO Go Client API Reference

Initialize MinIO Client object.

MinIO

package main

import (
    "log"

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

func main() {
    endpoint := "play.min.io"
    accessKeyID := "Q3AM3UQ867SPQQA43P2F"
    secretAccessKey := "zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG"
    useSSL := true

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

    log.Printf("%#v\n", minioClient) // minioClient is now setup
}

AWS S3

package main

import (
    "fmt"

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

func main() {
        // Initialize minio client object.
        s3Client, err := minio.New("s3.amazonaws.com", &minio.Options{
            Creds:  credentials.NewStaticV4("YOUR-ACCESSKEYID", "YOUR-SECRETACCESSKEY", ""),
            Secure: true,
        })
        if err != nil {
                fmt.Println(err)
                return
        }
}

1. Constructor

New(endpoint string, opts *Options) (*Client, error)

Initializes a new client object.

Parameters

minio.Options

2. Bucket operations

MakeBucket(ctx context.Context, bucketName string, opts MakeBucketOptions)

Creates a new bucket.

Parameters

Example

// 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.")

ListBuckets(ctx context.Context) ([]BucketInfo, error)

Lists all buckets.

minio.BucketInfo

Example

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

BucketExists(ctx context.Context, bucketName string) (found bool, err error)

Checks if a bucket exists.

Parameters

Return Values

Example

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

RemoveBucket(ctx context.Context, bucketName string) error

Removes a bucket, bucket should be empty to be successfully removed.

Parameters

Example

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

ListObjects(ctx context.Context, bucketName string, opts ListObjectsOptions) <-chan ObjectInfo

Lists objects in a bucket.

Parameters

Return Value

minio.ObjectInfo

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)
}

ListIncompleteUploads(ctx context.Context, bucketName, prefix string, recursive bool) <- chan ObjectMultipartInfo

Lists partially uploaded objects in a bucket.

Parameters

Return Value

minio.ObjectMultipartInfo

Example

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)
}

SetBucketTagging(ctx context.Context, bucketName string, tags *tags.Tags) error

Sets tags to a bucket.

Parameters

Example

// 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)
}

GetBucketTagging(ctx context.Context, bucketName string) (*tags.Tags, error)

Gets tags of a bucket.

Parameters

Return Value

Example

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

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

RemoveBucketTagging(ctx context.Context, bucketName string) error

Removes all tags on a bucket.

Parameters

Example

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

3. Object operations

GetObject(ctx context.Context, bucketName, objectName string, opts GetObjectOptions) (*Object, error)

Returns a stream of the object data. Most of the common errors occur when reading the stream.

Parameters

minio.GetObjectOptions

Return Value

Example

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
}

FGetObject(ctx context.Context, bucketName, objectName, filePath string, opts GetObjectOptions) error

Downloads and saves the object as a file in the local filesystem.

Parameters

Example

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

PutObjectFanOut(ctx context.Context, bucket string, body io.Reader, fanOutReq ...PutObjectFanOutRequest) ([]PutObjectFanOutResponse, error)

A variant of PutObject instead of writing a single object from a single stream multiple objects are written, defined via a list of
PutObjectFanOutRequest. Each entry in PutObjectFanOutRequest carries an object keyname and its relevant metadata if any.
Key is mandatory, rest of the other options in *PutObjectFanOutRequest( are optional.

Parameters

minio.PutObjectFanOutRequest

minio.PutObjectFanOutEntry

minio.PutObjectFanOutResponse

PutObject(ctx context.Context, bucketName, objectName string, reader io.Reader, objectSize int64,opts PutObjectOptions) (info UploadInfo, err error)

Uploads objects that are less than 128MiB in a single PUT operation. For objects that are greater than 128MiB in size, PutObject seamlessly uploads the object as parts of 128MiB or more depending on the actual file size. The max upload size for an object is 5TB.

Parameters

minio.PutObjectOptions

minio.UploadInfo

Example

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)

API methods PutObjectWithSize, PutObjectWithMetadata, PutObjectStreaming, and PutObjectWithProgress available in minio-go SDK release v3.0.3 are replaced by the new PutObject call variant that accepts a pointer to PutObjectOptions struct.

CopyObject(ctx context.Context, dst CopyDestOptions, src CopySrcOptions) (UploadInfo, error)

Create or replace an object through server-side copying of an existing object. It supports conditional copying, copying a part of an object and server-side encryption of destination and decryption of source. See the CopySrcOptions and DestinationInfo types for further details.

To copy multiple source objects into a single destination object see the ComposeObject API.

Parameters

minio.UploadInfo

Example

// 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(), dst, src)
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(), dst, src)
if err != nil {
    fmt.Println(err)
    return
}

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

ComposeObject(ctx context.Context, dst minio.CopyDestOptions, srcs ...minio.CopySrcOptions) (UploadInfo, error)

Create an object by concatenating a list of source objects using server-side copying.

Parameters

minio.UploadInfo

Example

// 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)

FPutObject(ctx context.Context, bucketName, objectName, filePath, opts PutObjectOptions) (info UploadInfo, err error)

Uploads contents from a file to objectName.

FPutObject uploads objects that are less than 128MiB in a single PUT operation. For objects that are greater than the 128MiB in size, FPutObject seamlessly uploads the object in chunks of 128MiB or more depending on the actual file size. The max upload size for an object is 5TB.

Parameters

minio.UploadInfo

Example

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)

StatObject(ctx context.Context, bucketName, objectName string, opts StatObjectOptions) (ObjectInfo, error)

Fetch metadata of an object.

Parameters

Return Value

minio.ObjectInfo

Example

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

RemoveObject(ctx context.Context, bucketName, objectName string, opts minio.RemoveObjectOptions) error

Removes an object with some specified options

Parameters

minio.RemoveObjectOptions

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

PutObjectRetention(ctx context.Context, bucketName, objectName string, opts minio.PutObjectRetentionOptions) error

Applies object retention lock onto an object.

Parameters

RemoveObjects(ctx context.Context, bucketName string, objectsCh <-chan ObjectInfo, opts RemoveObjectsOptions) <-chan RemoveObjectError

Removes a list of objects obtained from an input channel. The call sends a delete request to the server up to 1000 objects at a time. The errors observed are sent over the error channel.

Parameters

minio.RemoveObjectsOptions

Return Values

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)
}

GetObjectRetention(ctx context.Context, bucketName, objectName, versionID string) (mode *RetentionMode, retainUntilDate *time.Time, err error)

Returns retention set on a given object.

Parameters

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

PutObjectLegalHold(ctx context.Context, bucketName, objectName string, opts minio.PutObjectLegalHoldOptions) error

Applies legal-hold onto an object.

Parameters

minio.PutObjectLegalHoldOptions

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

GetObjectLegalHold(ctx context.Context, bucketName, objectName, versionID string) (status *LegalHoldStatus, err error)

Returns legal-hold status on a given object.

Parameters

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

SelectObjectContent(ctx context.Context, bucketName string, objectsName string, expression string, options SelectObjectOptions) *SelectResults

Parameters

Return Values

    // 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)
    }

PutObjectTagging(ctx context.Context, bucketName, objectName string, otags *tags.Tags) error

set new object Tags to the given object, replaces/overwrites any existing tags.

Parameters

Example

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

GetObjectTagging(ctx context.Context, bucketName, objectName string) (*tags.Tags, error)

Fetch Object Tags from the given object

Parameters

Example

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

RemoveObjectTagging(ctx context.Context, bucketName, objectName string) error

Remove Object Tags from the given object

Parameters

Example

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

RestoreObject(ctx context.Context, bucketName, objectName, versionID string, opts minio.RestoreRequest) error

Restore or perform SQL operations on an archived object

Parameters

Example

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)
}

GetObjectAttributes(ctx context.Context, bucketName, objectName string, opts ObjectAttributesOptions) (*ObjectAttributes, error)

Returns a stream of the object data. Most of the common errors occur when reading the stream.

Parameters

minio.ObjectAttributesOptions

Return Value

Example

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)

RemoveIncompleteUpload(ctx context.Context, bucketName, objectName string) error

Removes a partially uploaded object.

Parameters

Example

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

4. Presigned operations

PresignedGetObject(ctx context.Context, bucketName, objectName string, expiry time.Duration, reqParams url.Values) (*url.URL, error)

Generates a presigned URL for HTTP GET operations. Browsers/Mobile clients may point to this URL to directly download objects even if the bucket is private. This presigned URL can have an associated expiration time in seconds after which it is no longer operational. The maximum expiry is 604800 seconds (i.e. 7 days) and minimum is 1 second.

Parameters

Example

// 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)

PresignedPutObject(ctx context.Context, bucketName, objectName string, expiry time.Duration) (*url.URL, error)

Generates a presigned URL for HTTP PUT operations. Browsers/Mobile clients may point to this URL to upload objects directly to a bucket even if it is private. This presigned URL can have an associated expiration time in seconds after which it is no longer operational. The default expiry is set to 7 days.

NOTE: you can upload to S3 only with specified object name.

Parameters

Example

// 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)

PresignedHeadObject(ctx context.Context, bucketName, objectName string, expiry time.Duration, reqParams url.Values) (*url.URL, error)

Generates a presigned URL for HTTP HEAD operations. Browsers/Mobile clients may point to this URL to directly get metadata from objects even if the bucket is private. This presigned URL can have an associated expiration time in seconds after which it is no longer operational. The default expiry is set to 7 days.

Parameters

Example

// 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)

PresignedPostPolicy(ctx context.Context, post PostPolicy) (*url.URL, map[string]string, error)

Allows setting policy conditions to a presigned URL for POST operations. Policies such as bucket name to receive object uploads, key name prefixes, expiry policy may be set.

// 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)

5. Bucket policy/notification operations

SetBucketPolicy(ctx context.Context, bucketname, policy string) error

Set access permissions on bucket or an object prefix.

Parameters

Return Values

Example

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
}

GetBucketPolicy(ctx context.Context, bucketName string) (policy string, error)

Get access permissions on a bucket or a prefix.

Parameters

Return Values

Example

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

GetBucketNotification(ctx context.Context, bucketName string) (notification.Configuration, error)

Get notification configuration on a bucket.

Parameters

Return Values

Example

bucketNotification, err := minioClient.GetBucketNotification(context.Background(), "mybucket")
if err != nil {
    fmt.Println("Failed to get bucket notification configurations for mybucket", err)
    return
}

for _, queueConfig := range bucketNotification.QueueConfigs {
    for _, e := range queueConfig.Events {
        fmt.Println(e + " event is enabled")
    }
}

SetBucketNotification(ctx context.Context, bucketName string, config notification.Configuration) error

Set a new bucket notification on a bucket.

Parameters

Return Values

Example

queueArn := notification.NewArn("aws", "sqs", "us-east-1", "804605494417", "PhotoUpdate")

queueConfig := notification.NewConfig(queueArn)
queueConfig.AddEvents(minio.ObjectCreatedAll, minio.ObjectRemovedAll)
queueConfig.AddFilterPrefix("photos/")
queueConfig.AddFilterSuffix(".jpg")

config := notification.Configuration{}
config.AddQueue(queueConfig)

err = minioClient.SetBucketNotification(context.Background(), "mybucket", config)
if err != nil {
    fmt.Println("Unable to set the bucket notification: ", err)
    return
}

RemoveAllBucketNotification(ctx context.Context, bucketName string) error

Remove all configured bucket notifications on a bucket.

Parameters

Return Values

Example

err = minioClient.RemoveAllBucketNotification(context.Background(), "mybucket")
if err != nil {
    fmt.Println("Unable to remove bucket notifications.", err)
    return
}

ListenBucketNotification(context context.Context, bucketName, prefix, suffix string, events []string) <-chan notification.Info

ListenBucketNotification API receives bucket notification events through the notification channel. The returned notification channel has two fields 'Records' and 'Err'.

• 'Records' holds the notifications received from the server.
• 'Err' indicates any error while processing the received notifications.

NOTE: Notification channel is closed at the first occurrence of an error.

Parameters

Return Values

minio.NotificationInfo

|Field |Type |Description |
|notificationInfo.Records | []notification.Event | Collection of notification events |
|notificationInfo.Err | error | Carries any error occurred during the operation (Standard Error) |

Example

// Listen for bucket notifications on "mybucket" filtered by prefix, suffix and events.
for notificationInfo := range minioClient.ListenBucketNotification(context.Background(), "mybucket", "myprefix/", ".mysuffix", []string{
    "s3:ObjectCreated:*",
    "s3:ObjectAccessed:*",
    "s3:ObjectRemoved:*",
    }) {
    if notificationInfo.Err != nil {
        fmt.Println(notificationInfo.Err)
    }
    fmt.Println(notificationInfo)
}

ListenNotification(context context.Context, prefix, suffix string, events []string) <-chan notification.Info

ListenNotification API receives bucket and object notification events through the notification channel. The returned notification channel has two fields 'Records' and 'Err'.

• 'Records' holds the notifications received from the server.
• 'Err' indicates any error while processing the received notifications.

NOTE: Notification channel is closed at the first occurrence of an error.

Parameters

Return Values

minio.NotificationInfo

|Field |Type |Description |
|notificationInfo.Records | []notification.Event | Collection of notification events |
|notificationInfo.Err | error | Carries any error occurred during the operation (Standard Error) |

Example

// Listen for bucket notifications on "mybucket" filtered by prefix, suffix and events.
for notificationInfo := range minioClient.ListenNotification(context.Background(), "myprefix/", ".mysuffix", []string{
    "s3:BucketCreated:*",
    "s3:BucketRemoved:*",
    "s3:ObjectCreated:*",
    "s3:ObjectAccessed:*",
    "s3:ObjectRemoved:*",
    }) {
    if notificationInfo.Err != nil {
        fmt.Println(notificationInfo.Err)
    }
    fmt.Println(notificationInfo)
}

SetBucketLifecycle(ctx context.Context, bucketname, config *lifecycle.Configuration) error

Set lifecycle on bucket or an object prefix.

Parameters

Return Values

Example

config := lifecycle.NewConfiguration()
config.Rules = []lifecycle.Rule{
  {
    ID:     "expire-bucket",
    Status: "Enabled",
    Expiration: lifecycle.Expiration{
       Days: 365,
    },
  },
}

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

GetBucketLifecycle(ctx context.Context, bucketName string) (*lifecycle.Configuration error)

Get lifecycle on a bucket or a prefix.

Parameters

Return Values

Example

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

SetBucketEncryption(ctx context.Context, bucketname string, config sse.Configuration) error

Set default encryption configuration on a bucket.

Parameters

Return Values

Example

s3Client, err := minio.New("s3.amazonaws.com", &minio.Options{
    Creds:  credentials.NewStaticV4("YOUR-ACCESSKEYID", "YOUR-SECRETACCESSKEY", ""),
    Secure: true,
})
if err != nil {
    log.Fatalln(err)
}

// Set default encryption configuration on an S3 bucket
err = s3Client.SetBucketEncryption(context.Background(), "my-bucketname", sse.NewConfigurationSSES3())
if err != nil {
    log.Fatalln(err)
}

GetBucketEncryption(ctx context.Context, bucketName string) (*sse.Configuration, error)

Get default encryption configuration set on a bucket.

Parameters

Return Values

Example

s3Client, err := minio.New("s3.amazonaws.com", &minio.Options{
    Creds:  credentials.NewStaticV4("YOUR-ACCESSKEYID", "YOUR-SECRETACCESSKEY", ""),
    Secure: true,
})
if err != nil {
    log.Fatalln(err)
}

// Get default encryption configuration set on an S3 bucket and print it out
encryptionConfig, err := s3Client.GetBucketEncryption(context.Background(), "my-bucketname")
if err != nil {
    log.Fatalln(err)
}
fmt.Printf("%+v\n", encryptionConfig)

RemoveBucketEncryption(ctx context.Context, bucketName string) (error)

Remove default encryption configuration set on a bucket.

Parameters

Return Values

Example

err := s3Client.RemoveBucketEncryption(context.Background(), "my-bucketname")
if err != nil {
    log.Fatalln(err)
}
// "my-bucket" is successfully deleted/removed.

SetObjectLockConfig(ctx context.Context, bucketname, mode *RetentionMode, validity *uint, unit *ValidityUnit) error

Set object lock configuration in given bucket. mode, validity and unit are either all set or all nil.

Parameters

Return Values

Example

mode := Governance
validity := uint(30)
unit := Days

err = minioClient.SetObjectLockConfig(context.Background(), "my-bucketname", &mode, &validity, &unit)
if err != nil {
    fmt.Println(err)
    return
}

GetObjectLockConfig(ctx context.Context, bucketName string) (objectLock,*RetentionMode, *uint, *ValidityUnit, error)

Get object lock configuration of given bucket.

Parameters

Return Values

Example

enabled, mode, validity, unit, err := minioClient.GetObjectLockConfig(context.Background(), "my-bucketname")
if err != nil {
    log.Fatalln(err)
}
fmt.Println("object lock is %s for this bucket",enabled)
if mode != nil {
    fmt.Printf("%v mode is enabled for %v %v for bucket 'my-bucketname'\n", *mode, *validity, *unit)
} else {
    fmt.Println("No mode is enabled for bucket 'my-bucketname'")
}

EnableVersioning(ctx context.Context, bucketName string) error

Enable bucket versioning support.

Parameters

Return Values

Example

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

fmt.Println("versioning enabled for bucket 'my-bucketname'")

DisableVersioning(ctx context.Context, bucketName) error

Disable bucket versioning support.

Parameters

Return Values

Example

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

fmt.Println("versioning disabled for bucket 'my-bucketname'")

GetBucketVersioning(ctx context.Context, bucketName string) (BucketVersioningConfiguration, error)

Get versioning configuration set on a bucket.

Parameters

Return Values

Example

s3Client, err := minio.New("s3.amazonaws.com", &minio.Options{
    Creds:  credentials.NewStaticV4("YOUR-ACCESSKEYID", "YOUR-SECRETACCESSKEY", ""),
    Secure: true,
})
if err != nil {
    log.Fatalln(err)
}

// Get versioning configuration set on an S3 bucket and print it out
versioningConfig, err := s3Client.GetBucketVersioning(context.Background(), "my-bucketname")
if err != nil {
    log.Fatalln(err)
}
fmt.Printf("%+v\n", versioningConfig)

SetBucketReplication(ctx context.Context, bucketname, cfg replication.Config) error

Set replication configuration on a bucket. Role can be obtained by first defining the replication target on MinIO using mc admin bucket remote set to associate the source and destination buckets for replication with the replication endpoint.

Parameters

Return Values

Example

replicationStr := `<ReplicationConfiguration>
   <Role></Role>
   <Rule>
      <DeleteMarkerReplication>
         <Status>Disabled</Status>
      </DeleteMarkerReplication>
      <Destination>
         <Bucket>string</Bucket>
         <StorageClass>string</StorageClass>
      </Destination>
      <Filter>
         <And>
            <Prefix>string</Prefix>
            <Tag>
               <Key>string</Key>
               <Value>string</Value>
            </Tag>
            ...
         </And>
         <Prefix>string</Prefix>
         <Tag>
            <Key>string</Key>
            <Value>string</Value>
         </Tag>
      </Filter>
      <ID>string</ID>
      <Prefix>string</Prefix>
      <Priority>integer</Priority>
      <Status>string</Status>
   </Rule>
</ReplicationConfiguration>`
replicationConfig := replication.Config{}
if err := xml.Unmarshal([]byte(replicationStr), &replicationConfig); err != nil {
    log.Fatalln(err)
}
cfg.Role := "arn:minio:s3::598361bf-3cec-49a7-b529-ce870a34d759:*"
err = minioClient.SetBucketReplication(context.Background(), "my-bucketname", replicationConfig)
if err != nil {
    fmt.Println(err)
    return
}

GetBucketReplication(ctx context.Context, bucketName string) (replication.Config, error)

Get current replication config on a bucket.

Parameters

Return Values

Example

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

RemoveBucketReplication(ctx context.Context, bucketname string) error

Removes replication configuration on a bucket.

Parameters

Return Values

Example

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

GetBucketReplicationMetrics(ctx context.Context, bucketName string) (replication.Metrics, error)

Get latest replication metrics on a bucket. This is a MinIO specific extension.

Parameters

Return Values

Example

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

6. Client custom settings

SetAppInfo(appName, appVersion string)

Add custom application details to User-Agent.

Parameters

Example

// Set Application name and version to be used in subsequent API requests.
minioClient.SetAppInfo("myCloudApp", "1.0.0")

TraceOn(outputStream io.Writer)

Enables HTTP tracing. The trace is written to the io.Writer provided. If outputStream is nil, trace is written to os.Stdout.

Parameters

TraceOff()

Disables HTTP tracing.

SetS3TransferAccelerate(acceleratedEndpoint string)

Set AWS S3 transfer acceleration endpoint for all API requests hereafter.
NOTE: This API applies only to AWS S3 and is a no operation for S3 compatible object storage services.

Parameters