Initialize MinIO client object

MinIO

packagemainimport("log""github.com/minio/minio-go/v7""github.com/minio/minio-go/v7/pkg/credentials")funcmain(){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,})iferr!=nil{log.Fatalln(err)}log.Printf("%#v\n",minioClient)// minioClient is now setup}

AWS S3

packagemainimport("fmt""github.com/minio/minio-go/v7""github.com/minio/minio-go/v7/pkg/credentials")funcmain(){// Initialize minio client object.s3Client,err:=minio.New("s3.amazonaws.com",&minio.Options{Creds:credentials.NewStaticV4("YOUR-ACCESSKEYID","YOUR-SECRETACCESSKEY",""),Secure:true,})iferr!=nil{fmt.Println(err)return}}

1. Constructor

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

2. Bucket operations

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

// 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})iferr!=nil{fmt.Println(err)return}fmt.Println("Successfully created mybucket.")

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

buckets,err:=minioClient.ListBuckets(context.Background())iferr!=nil{fmt.Println(err)return}for_,bucket:=rangebuckets{fmt.Println(bucket)}

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

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

RemoveBucket(ctx context.Context, bucketName string) error

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

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

ctx,cancel:=context.WithCancel(context.Background())defercancel()objectCh:=minioClient.ListObjects(ctx,"mybucket",minio.ListObjectsOptions{Prefix:"myprefix",Recursive:true,})forobject:=rangeobjectCh{ifobject.Err!=nil{fmt.Println(object.Err)return}fmt.Println(object)}

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

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

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

// Create tags from a map.tags,err:=tags.NewTags(map[string]string{"Tag1":"Value1","Tag2":"Value2",},false)iferr!=nil{log.Fatalln(err)}err=minioClient.SetBucketTagging(context.Background(),"my-bucketname",tags)iferr!=nil{log.Fatalln(err)}

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

tags,err:=minioClient.GetBucketTagging(context.Background(),"my-bucketname")iferr!=nil{log.Fatalln(err)}fmt.Printf("Fetched Object Tags: %v\n",tags)

RemoveBucketTagging(ctx context.Context, bucketName string) error

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

3. Object operations

AppendObject(ctx context.Context, bucketName, objectName string, reader io.Reader, objectSize int64, opts AppendObjectOptions) (UploadInfo, error)

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

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

object,err:=minioClient.GetObject(context.Background(),"mybucket","myobject",minio.GetObjectOptions{})iferr!=nil{fmt.Println(err)return}deferobject.Close()localFile,err:=os.Create("/tmp/local-file.jpg")iferr!=nil{fmt.Println(err)return}deferlocalFile.Close()if_,err=io.Copy(localFile,object);err!=nil{fmt.Println(err)return}

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

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

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

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

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

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

// Use-case 1: Simple copy object with no conditions.// Source objectsrcOpts:=minio.CopySrcOptions{Bucket:"my-sourcebucketname",Object:"my-sourceobjectname",}// Destination objectdstOpts:=minio.CopyDestOptions{Bucket:"my-bucketname",Object:"my-objectname",}// Copy object calluploadInfo,err:=minioClient.CopyObject(context.Background(),dstOpts,srcOpts)iferr!=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 objectsrcOpts:=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 objectdstOpts:=minio.CopyDestOptions{Bucket:"my-bucketname",Object:"my-objectname",}// Copy object call_,err=minioClient.CopyObject(context.Background(),dstOpts,srcOpts)iferr!=nil{fmt.Println(err)return}fmt.Println("Successfully copied object:",uploadInfo)

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

// 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 eachsrc1Opts:=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 keysseDst:=encrypt.DefaultPBKDF([]byte("new-password"),[]byte("new-salt"))// Create destination infodstOpts:=CopyDestOptions{Bucket:"bucket",Object:"object",Encryption:sseDst,}// Compose object call by concatenating multiple source files.uploadInfo,err:=minioClient.ComposeObject(context.Background(),dst,srcs...)iferr!=nil{fmt.Println(err)return}fmt.Println("Composed object successfully:",uploadInfo)

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

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

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

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

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

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

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

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

objectsCh:=make(chanminio.ObjectInfo)// Send object names that are needed to be removed to objectsChgofunc(){deferclose(objectsCh)// List all objects from a bucket-name with a matching prefix.forobject:=rangeminioClient.ListObjects(context.Background(),"my-bucketname","my-prefixname",true,nil){ifobject.Err!=nil{log.Fatalln(object.Err)}objectsCh<-object}}()opts:=minio.RemoveObjectsOptions{GovernanceBypass:true,}forrErr:=rangeminioClient.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)

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

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

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

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

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

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

// 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)iferr!=nil{log.Fatalln(err)}deferreader.Close()if_,err:=io.Copy(os.Stdout,reader);err!=nil{log.Fatalln(err)}

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

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

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

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

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

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

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

opts:=minio.RestoreRequest{}opts.SetDays(1)opts.SetGlacierJobParameters(minio.GlacierJobParameters{Tier:minio.TierStandard})err=s3Client.RestoreObject(context.Background(),"your-bucket","your-object","",opts)iferr!=nil{log.Fatalln(err)}

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

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

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

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

4. Presigned operations

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

// 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)iferr!=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 url which expires in a day.expiry:=time.Second*24*60*60// 1 day.presignedURL,err:=minioClient.PresignedPutObject(context.Background(),"mybucket","myobject",expiry)iferr!=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)

// 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)iferr!=nil{fmt.Println(err)return}fmt.Println("Successfully generated presigned URL",presignedURL)

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

// 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)iferr!=nil{fmt.Println(err)return}// POST your content from the command line using `curl`fmt.Printf("curl ")fork,v:=rangeformData{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

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)iferr!=nil{fmt.Println(err)return}

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

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

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

bucketNotification,err:=minioClient.GetBucketNotification(context.Background(),"mybucket")iferr!=nil{fmt.Println("Failed to get bucket notification configurations for mybucket",err)return}for_,queueConfig:=rangebucketNotification.QueueConfigs{for_,e:=rangequeueConfig.Events{fmt.Println(e+" event is enabled")}}

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

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)iferr!=nil{fmt.Println("Unable to set the bucket notification: ",err)return}

RemoveAllBucketNotification(ctx context.Context, bucketName string) error

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

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

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

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

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

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

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)iferr!=nil{fmt.Println(err)return}

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

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

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

s3Client,err:=minio.New("s3.amazonaws.com",&minio.Options{Creds:credentials.NewStaticV4("YOUR-ACCESSKEYID","YOUR-SECRETACCESSKEY",""),Secure:true,})iferr!=nil{log.Fatalln(err)}// Set default encryption configuration on an S3 bucketerr=s3Client.SetBucketEncryption(context.Background(),"my-bucketname",sse.NewConfigurationSSES3())iferr!=nil{log.Fatalln(err)}

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

s3Client,err:=minio.New("s3.amazonaws.com",&minio.Options{Creds:credentials.NewStaticV4("YOUR-ACCESSKEYID","YOUR-SECRETACCESSKEY",""),Secure:true,})iferr!=nil{log.Fatalln(err)}// Get default encryption configuration set on an S3 bucket and print it outencryptionConfig,err:=s3Client.GetBucketEncryption(context.Background(),"my-bucketname")iferr!=nil{log.Fatalln(err)}fmt.Printf("%+v\n",encryptionConfig)

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

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

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

mode:=Governancevalidity:=uint(30)unit:=Dayserr=minioClient.SetObjectLockConfig(context.Background(),"my-bucketname",&mode,&validity,&unit)iferr!=nil{fmt.Println(err)return}

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

enabled,mode,validity,unit,err:=minioClient.GetObjectLockConfig(context.Background(),"my-bucketname")iferr!=nil{log.Fatalln(err)}fmt.Println("object lock is %s for this bucket",enabled)ifmode!=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

err:=minioClient.EnableVersioning(context.Background(),"my-bucketname")iferr!=nil{log.Fatalln(err)}fmt.Println("versioning enabled for bucket 'my-bucketname'")