Initialize MinIO client object

MinIO

import*asMiniofrom'minio'constminioClient=newMinio.Client({endPoint:'play.min.io',port:9000,useSSL:true,accessKey:'Q3AM3UQ867SPQQA43P2F',secretKey:'zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG',})

AWS S3

import*asMiniofrom'minio'consts3Client=newMinio.Client({endPoint:'s3.amazonaws.com',accessKey:'YOUR-ACCESSKEYID',secretKey:'YOUR-SECRETACCESSKEY',})

1. Constructor

new Minio.Client ({endPoint, port, useSSL, accessKey, secretKey, region, transport, sessionToken, partSize})

Create client for MinIO

import*asMiniofrom'minio'constminioClient=newMinio.Client({endPoint:'play.min.io',port:9000,useSSL:true,accessKey:'Q3AM3UQ867SPQQA43P2F',secretKey:'zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG',})

Create client for AWS S3

import*asMiniofrom'minio'consts3Client=newMinio.Client({endPoint:'s3.amazonaws.com',accessKey:'YOUR-ACCESSKEYID',secretKey:'YOUR-SECRETACCESSKEY',})

Create client with temporary credentials

import*asMiniofrom'minio'consts3Client=newMinio.Client({endPoint:'s3.amazonaws.com',accessKey:'YOUR-TEMP-ACCESSKEYID',secretKey:'YOUR-TEMP-SECRETACCESSKEY',sessionToken:'YOUR-TEMP-SESSIONTOKEN',})

Create client with custom HTTPS Agent

import*asMiniofrom'minio'import*asfsfrom'fs'import*ashttpsfrom'https'consts3Client=newMinio.Client({endPoint:'play.min.io',port:9000,useSSL:true,accessKey:'Q3AM3UQ867SPQQA43P2F',secretKey:'zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG',transportAgent:newhttps.Agent({timeout:10000,ca:fs.readFileSync('path/to/ca.cert'),cert:fs.readFileSync('path/to/public.cert'),key:fs.readFileSync('path/to/secret.key'),keepAlive:false,}),})

Note: The below examples may rely on top level await.

2. Bucket operations

async makeBucket(bucketName, [region, makeOpts]): Promise

awaitminioClient.makeBucket('mybucket','us-east-1')console.log('Bucket created successfully in "us-east-1".')

minioClient.makeBucket('mybucket','us-east-1',{ObjectLocking:true},function(err){if(err)returnconsole.log('Error creating bucket with object lock.',err)console.log('Bucket created successfully in "us-east-1" and enabled object lock')})

listBuckets()

try{constbuckets=awaitminioClient.listBuckets()console.log('Success',buckets)}catch(err){console.log(err.message)}

async bucketExists(bucketName): Promise

constexists=awaitminioClient.bucketExists('mybucket')if(exists){returnconsole.log('Bucket exists.')}

removeBucket(bucketName[, callback])

try{awaitminioClient.removeBucket('mybucket')console.log('Bucket removed successfully.')}catch(err){console.log('unable to remove bucket.')}

listObjects(bucketName, prefix, recursive [,listOpts])

constdata=[]conststream=minioClient.listObjects('mybucket','',true)stream.on('data',function(obj){data.push(obj)})stream.on('end',function(){console.log(data)})stream.on('error',function(err){console.log(err)})

constdata=[]conststream=minioClient.listObjects('mybucket','',true,{IncludeVersion:true})stream.on('data',function(obj){data.push(obj)})stream.on('end',function(){console.log(data)})stream.on('error',function(err){console.log(err)})

listObjectsV2(bucketName, prefix, recursive, startAfter)

conststream=minioClient.listObjectsV2('mybucket','',true,'')stream.on('data',function(obj){console.log(obj)})stream.on('error',function(err){console.log(err)})

listObjectsV2WithMetadata(bucketName, prefix, recursive, startAfter)

conststream=minioClient.extensions.listObjectsV2WithMetadata('mybucket','',true,'')stream.on('data',function(obj){console.log(obj)})stream.on('error',function(err){console.log(err)})

listIncompleteUploads(bucketName, prefix, recursive)

constStream=minioClient.listIncompleteUploads('mybucket','',true)Stream.on('data',function(obj){console.log(obj)})Stream.on('end',function(){console.log('End')})Stream.on('error',function(err){console.log(err)})

getBucketVersioning(bucketName)

constversionInfo=awaitminioClient.getBucketVersioning('bucketname')console.log('Success ',versionInfo)

setBucketVersioning(bucketName, versioningConfig)

constversioningConfig={Status:'Enabled'}awaitminioClient.setBucketVersioning('bucketname',versioningConfig)

setBucketReplication(bucketName, replicationConfig)

constarnFromMcCli='arn:minio:replication::b22d653b-e4fb-4c5d-8140-7694c8e72ed4:dest-bucket'constreplicationConfig={role:arnFromMcCli,rules:[{ID:'cisea130mbms6splbmg0',Status:'Enabled',Priority:1,DeleteMarkerReplication:{Status:'Enabled'},DeleteReplication:{Status:'Enabled'},Destination:{Bucket:'arn:aws:s3:::dest-bucket',StorageClass:'REDUCED_REDUNDANCY',},SourceSelectionCriteria:{ReplicaModifications:{Status:'Enabled'}},Filter:{//Possible values.// Prefix: '/',// Tag: [{ 'Key': 'key1', 'Value': 'value1' }, { 'Key': 'key2', 'Value': 'value2' }],//if only this,  =>    'DeleteMarkerReplication': { 'Status': 'Disabled' },And:{Prefix:'/',Tag:[{Key:'key1',Value:'value1'},{Key:'key2',Value:'value2'},],},},ExistingObjectReplication:{Status:'Enabled'},},],}awaits3Client.setBucketReplication('source-bucket',replicationConfig)

getBucketReplication(bucketName)

constreplicatinConfig=awaitminioClient.getBucketReplication('source-bucket')console.log(replicatinConfig)

removeBucketReplication(bucketName)

awaitminioClient.removeBucketReplication('source-bucket')

setBucketTagging(bucketName, tags)

awaitminioClient.setBucketTagging('bucketname',tags)

removeBucketTagging(bucketName, callback)

awaitminioClient.removeBucketTagging('bucketname')

getBucketTagging(bucketName)

consttagList=awaitminioClient.getBucketTagging('bucketname')console.log(tagList)

setBucketLifecycle(bucketName, lifecycleConfig)

constlifecycleConfig={Rule:[{ID:'Transition and Expiration Rule',Status:'Enabled',Filter:{Prefix:'',},Expiration:{Days:'3650',},},],}awaitminioClient.setBucketLifecycle('bucketname',lifecycleConfig)

getBucketLifecycle(bucketName)

awaitminioClient.getBucketLifecycle('bucketname')

removeBucketLifecycle(bucketName)

awaitminioClient.removeBucketLifecycle('bucketname')

setObjectLockConfig(bucketName, lockConfig [, callback])

awaitminioClient.setObjectLockConfig('my-bucketname',{mode:'COMPLIANCE',unit:'Days',validity:10})

awaits3Client.setObjectLockConfig('my-bucketname',{})

getObjectLockConfig(bucketName [, callback])

awaitminioClient.getObjectLockConfig('my-bucketname')

setBucketEncryption(bucketName [,encryptionConfig])

awaits3Client.setBucketEncryption('my-bucketname')

awaits3Client.setBucketEncryption('my-bucketname',{Rule:[{ApplyServerSideEncryptionByDefault:{SSEAlgorithm:'AES256'}}],})

getBucketEncryption(bucketName)

awaits3Client.getBucketEncryption('my-bucketname')

removeBucketEncryption(bucketName)

awaits3Client.removeBucketEncryption('my-bucketname')

3. Object operations

getObject(bucketName, objectName, getOpts)

letsize=0constdataStream=awaitminioClient.getObject('mybucket','photo.jpg')dataStream.on('data',function(chunk){size+=chunk.length})dataStream.on('end',function(){console.log('End. Total size = '+size)})dataStream.on('error',function(err){console.log(err)})

letsize=0constdataStream=awaitminioClient.getObject('mybucket','photo.jpg',{versionId:'my-versionId'})dataStream.on('data',function(chunk){size+=chunk.length})dataStream.on('end',function(){console.log('End. Total size = '+size)})dataStream.on('error',function(err){console.log(err)})

letsize=0constdataStream=awaitminioClient.getObject('mybucket','photo.jpg',{SSECustomerAlgorithm:'AES256',SSECustomerKey:'YOUR_KEY',SSECustomerKeyMD5:'YOUR_MD5',})dataStream.on('data',function(chunk){size+=chunk.length})dataStream.on('end',function(){console.log('End. Total size = '+size)})dataStream.on('error',function(err){console.log(err)})

getPartialObject(bucketName, objectName, offset, length, getOpts[, callback])

letsize=0// reads 30 bytes from the offset 10.constdataStream=awaitminioClient.getPartialObject('mybucket','photo.jpg',10,30)dataStream.on('data',function(chunk){size+=chunk.length})dataStream.on('end',function(){console.log('End. Total size = '+size)})dataStream.on('error',function(err){console.log(err)})

constversionedObjSize=0// reads 30 bytes from the offset 10.constdataStream=awaitminioClient.getPartialObject('mybucket','photo.jpg',10,30,{versionId:'my-versionId'})dataStream.on('data',function(chunk){versionedObjSize+=chunk.length})dataStream.on('end',function(){console.log('End. Total size = '+versionedObjSize)})dataStream.on('error',function(err){console.log(err)})

constversionedObjSize=0// reads 30 bytes from the offset 10.constdataStream=awaitminioClient.getPartialObject('mybucket','photo.jpg',10,30,{SSECustomerAlgorithm:'AES256',SSECustomerKey:'YOUR_KEY',SSECustomerKeyMD5:'YOUR_MD5',})dataStream.on('data',function(chunk){versionedObjSize+=chunk.length})dataStream.on('end',function(){console.log('End. Total size = '+versionedObjSize)})dataStream.on('error',function(err){console.log(err)})

fGetObject(bucketName, objectName, filePath, getOpts[, callback])

minioClient.fGetObject('mybucket','photo.jpg','/tmp/photo.jpg',function(err){if(err){returnconsole.log(err)}console.log('success')})

minioClient.fGetObject(bucketName,objNameValue,'./download/MyImage.jpg',{versionId:'my-versionId'},function(e){if(e){returnconsole.log(e)}console.log('success')})

minioClient.fGetObject(bucketName,objNameValue,'./download/MyImage.jpg',{SSECustomerAlgorithm:'AES256',SSECustomerKey:'YOUR_KEY',SSECustomerKeyMD5:'YOUR_MD5',},function(e){if(e){returnconsole.log(e)}console.log('success')},)

putObject(bucketName, objectName, stream, size, metaData[, callback])

From a stream

import*asFsfrom'fs'constfile='/tmp/40mbfile'constfileStream=Fs.createReadStream(file)constfileStat=Fs.stat(file,function(err,stats){if(err){returnconsole.log(err)}minioClient.putObject('mybucket','40mbfile',fileStream,stats.size,function(err,objInfo){if(err){returnconsole.log(err)// err should be null}console.log('Success',objInfo)})})

From a “Buffer” or a “string”

constbuffer='Hello World'minioClient.putObject('mybucket','hello-file',buffer,function(err,etag){returnconsole.log(err,etag)// err should be null})

fPutObject(bucketName, objectName, filePath, metaData[, callback])

constfile='/tmp/40mbfile'constmetaData={'Content-Type':'text/html','Content-Language':123,'X-Amz-Meta-Testing':1234,example:5678,}minioClient.fPutObject('mybucket','40mbfile',file,metaData,function(err,objInfo){if(err){returnconsole.log(err)}console.log('Success',objInfo.etag,objInfo.versionId)})

copyObject(targetBucketName, targetObjectName, sourceBucketNameAndObjectName [,conditions])

constconds=newMinio.CopyConditions()conds.setMatchETag('bd891862ea3e22c93ed53a098218791d')awaitminioClient.copyObject('mybucket','newobject','/mybucket/srcobject',conds)

statObject(bucketName, objectName, statOpts[, callback])

conststat=awaitminioClient.statObject('mybucket','photo.jpg')console.log(stat)

conststat=awaitminioClient.statObject('mybucket','photo.jpg',{versionId:'my-versionId'})console.log(stat)

removeObject(bucketName, objectName [, removeOpts])

;(asyncfunction(){awaitminioClient.removeObject('mybucket','photo.jpg')console.log('Removed the object')})()

;(asyncfunction(){try{awaitminioClient.removeObject('mybucket','photo.jpg',{versionId:'my-versionId'})console.log('Removed the object')}catch(err){console.log('Unable to remove object',err)}})()

;(asyncfunction(){awaits3Client.removeObject('my-bucketname','my-objectname',{versionId:'my-versionId',governanceBypass:true})console.log('Success')})()

removeObjects(bucketName, objectsList)

constobjectsList=[]// List all object paths in bucket my-bucketname.constobjectsStream=s3Client.listObjects('my-bucketname','my-prefixname',true)objectsStream.on('data',function(obj){objectsList.push(obj.name)})objectsStream.on('error',function(e){console.log(e)})objectsStream.on('end',async()=>{awaits3Client.removeObjects(bucket,objectsList)})

constobjectsList=[]constbucket='my-bucket'constprefix='my-prefix'constrecursive=falseconstobjectsStream=s3Client.listObjects(bucket,prefix,recursive,{IncludeVersion:true})objectsStream.on('data',function(obj){objectsList.push(obj)})objectsStream.on('error',function(e){returnconsole.log(e)})objectsStream.on('end',async()=>{awaits3Client.removeObjects(bucket,objectsList)})

removeIncompleteUpload(bucketName, objectName)

awaitminioClient.removeIncompleteUpload('mybucket','photo.jpg')

async putObjectRetention(bucketName, objectName [, retentionOpts])

constbucketName='my-bucket'constobjectName='my-object'constexpirationDate=newDate()expirationDate.setDate(expirationDate.getDate()+1)expirationDate.setUTCHours(0,0,0,0)//Should be start of the day.(midnight)constversionId='e67b4b08-144d-4fc4-ba15-43c3f7f9ba74'awaitminioClient.putObjectRetention(bucketName,objectName,{Mode:'GOVERNANCE',retainUntilDate:retainUntilDate.toISOString(),versionId:versionId,})

getObjectRetention(bucketName, objectName [, getOpts])

constretentionInfo=awaitminioClient.getObjectRetention('bucketname','objectname')console.log(retentionInfo)

constretInfoForVersionId=awaitminioClient.getObjectRetention('bucketname','objectname',{versionId:'my-versionId',})console.log(retInfoForVersionId)

setObjectTagging(bucketName, objectName, tags[, putOpts])

awaitminioClient.setObjectTagging('bucketname','object-name',tags)

awaitminioClient.setObjectTagging('bucketname','object-name',tags,{versionId:'my-version-id'})

removeObjectTagging(bucketName, objectName[, removeOpts])

awaitminioClient.removeObjectTagging('bucketname','object-name')

awaitminioClient.removeObjectTagging('bucketname','object-name',{versionId:'my-object-version-id'})

getObjectTagging(bucketName, objectName[, getOpts])

console.log(awaitminioClient.getObjectTagging('bucketname','object-name'))

console.log(awaitminioClient.getObjectTagging('bucketname','object-name',{versionId:'my-object-version-id'}))

getObjectLegalHold(bucketName, objectName, getOpts)

constlegalholdStatus=awaitminioClient.getObjectLegalHold('bucketName','objectName')

constlegalholdStatus=awaitminioClient.getObjectLegalHold('bucketName','objectName',{versionId:'my-obj-version-uuid',})

setObjectLegalHold(bucketName, objectName, [,setOpts])

constlegalholdStatus=awaitminioClient.setObjectLegalHold('bucketName','objectName',{Status:'ON'})

constlegalholdStatus=awaitminioClient.setObjectLegalHold('bucketName','objectName',{Status:'ON',versionId:'my-obj-version-uuid',})

composeObject(destObjConfig, sourceObjectList)

import*asminiofrom'minio'constsourceList=[newminio.CopySourceOptions({Bucket:'source-bucket',Object:'parta',}),newminio.CopySourceOptions({Bucket:'source-bucket',Object:'partb',}),newminio.CopySourceOptions({Bucket:'source-bucket',Object:'partc',}),newminio.CopySourceOptions({Bucket:'source-bucket',Object:'partd',}),]constdestOption=newminio.CopyDestinationOptions({Bucket:'dest-bucket',Object:'100MB.zip',})//using Promise style.awaitminioClient.composeObject(destOption,sourceList)

selectObjectContent(bucketName, objectName, selectOpts)

constselectOpts={expression:'SELECT * FROM s3object s where s."Name" = \'Jane\'',expressionType:'SQL',inputSerialization:{CSV:{FileHeaderInfo:'Use',RecordDelimiter:'\n',FieldDelimiter:','},CompressionType:'NONE',},outputSerialization:{CSV:{RecordDelimiter:'\n',FieldDelimiter:','}},requestProgress:{Enabled:true},}constres=awaitminioClient.selectObjectContent('bucketName','objectName',selectOpts)console.log(res)

4. Presigned operations

presignedUrl(httpMethod, bucketName, objectName[, expiry, reqParams, requestDate])

// presigned url for 'getObject' method.// expires in a day.constpresignedUrl=awaitminioClient.presignedUrl('GET','mybucket','hello.txt',24*60*60)console.log(presignedUrl)

// presigned url for 'listObject' method.// Lists objects in 'myBucket' with prefix 'data'.// Lists max 1000 of them.awaitminioClient.presignedUrl('GET','mybucket','',1000,{prefix:'data','max-keys':1000})

// Get Object with versionidawaitminioClient.presignedUrl('GET','mybucket','',1000,{versionId:'10fa9946-3f64-4137-a58f-888065c0732e'})

presignedGetObject(bucketName, objectName[, expiry, respHeaders, requestDate])

// expires in a day.constpresignedUrl=awaitminioClient.presignedGetObject('mybucket','hello.txt',24*60*60)console.log(presignedUrl)

presignedPutObject(bucketName, objectName [,expiry])

// expires in a day.constpresignedUrl=awaitminioClient.presignedPutObject('mybucket','hello.txt',24*60*60)console.log(presignedUrl)

presignedPostPolicy(policy)

constpolicy=minioClient.newPostPolicy()

// Policy restricted only for bucket 'mybucket'.policy.setBucket('mybucket')// Policy restricted only for hello.txt object.policy.setKey('hello.txt')

// Policy restricted for incoming objects with keyPrefix.policy.setKeyStartsWith('keyPrefix')constexpires=newDate()expires.setSeconds(24*60*60*10)// Policy expires in 10 days.policy.setExpires(expires)// Only allow 'text'.policy.setContentType('text/plain')// Set content disposition response header.policy.setContentDisposition('attachment; filename=text.txt')// Only allow content size in range 1KB to 1MB.policy.setContentLengthRange(1024,1024*1024)// Set key-value user defined metadatapolicy.setUserMetaData({key:'value',})

const{postURL,formData}=awaitminioClient.presignedPostPolicy(policy)constreq=superagent.post(postURL)_.each(formData,function(value,key){req.field(key,value)})// file contents.req.attach('file','/path/to/hello.txt','hello.txt')req.end(function(err,res){if(err){returnconsole.log(err.toString())}console.log('Upload successful.')})

5. Bucket Policy & Notification operations

getBucketNotification(bucketName[, cb])

minioClient.getBucketNotification('mybucket',function(err,bucketNotificationConfig){if(err)returnconsole.log(err)console.log(bucketNotificationConfig)})

setBucketNotification(bucketName, bucketNotificationConfig[, callback])

// Create a new notification objectconstbucketNotification=newMinio.NotificationConfig()// Setup a new Queue configurationconstarn=Minio.buildARN('aws','sqs','us-west-2','1','webhook')constqueue=newMinio.QueueConfig(arn)queue.addFilterSuffix('.jpg')queue.addFilterPrefix('myphotos/')queue.addEvent(Minio.ObjectReducedRedundancyLostObject)queue.addEvent(Minio.ObjectCreatedAll)// Add the queue to the overall notification objectbucketNotification.add(queue)minioClient.setBucketNotification('mybucket',bucketNotification,function(err){if(err)returnconsole.log(err)console.log('Success')})

removeAllBucketNotification(bucketName[, callback])

minioClient.removeAllBucketNotification('my-bucketname',function(e){if(e){returnconsole.log(e)}console.log('True')})

listenBucketNotification(bucketName, prefix, suffix, events)

constlistener=minioClient.listenBucketNotification('my-bucketname','photos/','.jpg',['s3:ObjectCreated:*'])listener.on('notification',function(record){// For example: 's3:ObjectCreated:Put event occurred (2016-08-23T18:26:07.214Z)'console.log('%s event occurred (%s)',record.eventName,record.eventTime)listener.stop()})

async getBucketPolicy(bucketName: string): Promise

// Retrieve bucket policy of 'my-bucketname'constpolicy=awaitminioClient.getBucketPolicy('my-bucketname')console.log(`Bucket policy file:${policy}`)

async setBucketPolicy(bucketName, bucketPolicy): Promise

// Set the bucket policy of `my-bucketname`awaitminioClient.setBucketPolicy('my-bucketname',JSON.stringify(policy))

6. Custom settings

setS3TransferAccelerate(endpoint)

7. HTTP request options

setRequestOptions(options)

// Do not reject self signed certificates.minioClient.setRequestOptions({rejectUnauthorized:false})

7. Explore Further