脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 脚本专栏 → Golang → Golang使用MinIO

Golang使用MinIO的方案详解

 更新时间：2023年08月19日 09:48:20   作者：HumbleSwage  
这篇文章主要介绍了Golang使用MinIO的过程，本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下

最近在使用Golang做了一个网盘项目（学习），文件存储一直保存在本地（各厂商提供的oss贵），所以就在思考怎么来处理这些文件，类似的方案很对hdfs、fastdfs，但这其中MinIO是最近几年比较火热的一个项目，所以尝试使用这个试一试。

1、MinIO的安装

MinIO的安装特别简单，大家可以前去官网按照步骤完成，注意以下几点即可

  • 注意你服务器是amd还是arm架构
  • 注意你自己的网络
  • 确保你按照官网的命令开启了minio服务
minio server ~/minio --console-address :9090

目前不要随便乱修改，按照原始的方案

2、创建Golang项目

mkdir minio-api
cd minio-api
go mod init v1

3、Goland打开项目构建一个上传文件demo

创建一个main.go，在这个函数中我们首先创建一个用于初始化MinIOClient的函数，该函数细节如下：

func InitMinioClient() *minio.Client {
	// 基本的配置信息
	endpoint := "172.16.59.130:9000"
	accessKeyID := "IdoSKNGz7evlQXVVqGJF"
	secretAccessKey := "s4hnwC9yWOsU8TTmODFcMcw0TdExa4GsTpGzibEc"
	// 初始化一个minio客户端对象
	minioClient, err := minio.New(endpoint, &minio.Options{
		Creds: credentials.NewStaticV4(accessKeyID, secretAccessKey, ""),
	})
	if err != nil {
		log.Fatalf("初始化MinioClient错误：%s", err.Error())
	}
	return minioClient
}

有几点基本的注意事项，首先是基本的配置信息你需要更改为你自己的，一般端口都为9000（注意不是9090），针对这个地方的accessKeyID和secretAccessKey的创建如下图：

在这里插入图片描述

然后我们构建一个main函数，在这个main函数中，我们首先调用初始化客户端的函数InitMinioClient，然后我们在main实现一个简单的上传文件的demo

func main() {
	// 创建客户端
	minioClient := InitMinioClient()
	// bucket名称
	bucketName := "mypic"
	ctx := context.Background()
	// 创建这个bucket
	err := minioClient.MakeBucket(ctx, bucketName, minio.MakeBucketOptions{})
	if err != nil {
		// 检测这个bucket是否已经存在
		exists, errBucketExists := minioClient.BucketExists(ctx, bucketName)
		if errBucketExists == nil && exists {
			log.Printf("We already own %s\n", bucketName)
		} else {
			log.Fatalln(err)
		}
	} else {
		log.Printf("Successfully created %s\n", bucketName)
	}
	// 需要上传文件的基本信息
	objectName := "头像.jpg"
	filePath := "image"
	contentType := "multipart/form-data"
	fPath := filepath.Join(filePath, objectName)
	fileInfo, err := os.Stat(fPath)
	if err == os.ErrNotExist {
		log.Printf("%s目标文件不存在", fPath)
	}
	f, err := os.Open(fPath)
	if err != nil {
		return
	}
	uploadInfo, err := minioClient.PutObject(ctx, bucketName, objectName, f, fileInfo.Size(), minio.PutObjectOptions{ContentType: contentType})
	if err != nil {
		log.Fatalln(err)
	}
	log.Printf("Successfully uploaded %s of size %d\n", objectName, uploadInfo.Size)
}

在这里插入图片描述

上传文件即成功，然后打开网页页面刷新，出现下面页面即可，同时你打开你的服务器可以发现你上传的文件。

在这里插入图片描述

观察上面的代码，至少包括三个API，包括创建Bucket、检测Bucket是否存在、上传文件到指定的Bucket。为了更好的研究这些API，现在我从Bucket开始研究一下常用的API。

4.创建客户端对象

API接口

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

初步观察这个接口，在结合我们上面的示例，可以发现：

  • endpoint：目前存储地址（127.0.0.1:9000），当然这里需要根据自身开启的minio服务所在的位置和服务端口。
  • opts：这个是一个minio.Options对象，然后我们来具体了解一哈这个对象有哪些常用的属性（注意这些属性的类）：
    • Creds：存储的一个身份信任
    • Secure：API的请求方式（HTTP/HTTPS）
  • 完整的一个创建Client的代码（可以根据自身需要再改造）
func InitMinioClient() *minio.Client {
	// 基本的配置信息
	endpoint := "172.16.59.130:9000"
	accessKeyID := "IdoSKNGz7evlQXVVqGJF"
	secretAccessKey := "s4hnwC9yWOsU8TTmODFcMcw0TdExa4GsTpGzibEc"
	// 初始化一个minio客户端对象
	minioClient, err := minio.New(endpoint, &minio.Options{
		Creds: credentials.NewStaticV4(accessKeyID, secretAccessKey, ""),
	})
	if err != nil {
		log.Fatalf("初始化MinioClient错误：%s", err.Error())
	}
	return minioClient
}

你自己可以尝试：创建一个bucket01和bucket02

5.Bucket的基本操作

5.1 创建Bucket

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

前两个参数不作过多的介绍，非常的清晰（所谓的BuketName，你可以简单理解为就是你文件保存的文件夹），在这里我们详细得介绍一哈MakeBucketOptions（minio.MakeBucketOptions），其主要是用于指定Bucket的一些选项比如说 Region （这个地方的Region表示在哪里创建你的Bucket，默认为 us-east-1 ，其它的一些选项可以参考官网文档，在这里需要注意，如果你是自己服务器搭建，而不是使用他所提供的存储服务，其实你是不用指定这个，就默认值问题也不大），一个完整的示例如下（确保你事先已经有这样的 minioClient ）：

err = minioClient.MakeBucket(context.Background(),minio.MakeBucketOptions{Region: "us-east-1", ObjectLocking: true})
if err != nil {
    fmt.Println(err)
    return
}
fmt.Println("Successfully created mybucket.")

5.2 展示Bucket

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

这个接口非常明了，返回的是一个BucketInfo的slice，在这里我们可以遍历该元素然后获取到对应的BucketInfo对象，直接看下面的demo：

func ListBuckets(minioClient *minio.Client) {
	bucketInfos, err := minioClient.ListBuckets(context.Background())
	if err != nil {
		fmt.Println("List Buckets err：", err.Error())
		return
	}
	for index, bucketInfo := range bucketInfos {
		fmt.Printf("List Bucket No {%d}----filename{%s}-----createTime{%s}\n", index+1, bucketInfo.Name, bucketInfo.CreationDate.Format("2006-01-02 15:04:05"))
	}
}

输出为：

List Bucket No {1}----filename{bucket01}-----createTime{2023-08-18 04:03:18}
List Bucket No {2}----filename{bucket02}-----createTime{2023-08-18 03:54:42}
注意：bucket是不支持修改名称的，如果你要修改名称，一般是新建一个bucket然后讲原来需要改名的bucket的内容移到新建的一个bucket。

5.3 检测Bucket

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

检查Bucket是否存在，查看下面demo：

func CheckBuckets(minioClient *minio.Client) {
	bucketName01 := "bucket01"
	bucketName02 := "bucket03"
	isExist, err := minioClient.BucketExists(context.Background(), bucketName01)
	if err != nil {
		fmt.Printf("Check %s err：%s", bucketName01, err.Error())
		return
	}
	if isExist {
		fmt.Printf("%s exists!\n", bucketName01)
	} else {
		fmt.Printf("%s not exists!\n", bucketName01)
	}
	isExist, err = minioClient.BucketExists(context.Background(), bucketName02)
	if err != nil {
		fmt.Printf("Check %s err：%s", bucketName02, err.Error())
		return
	}
	if isExist {
		fmt.Printf("%s exists!\n", bucketName02)
	} else {
		fmt.Printf("%s not exists!\n", bucketName02)
	}
}

输出：

bucket01 exists!

bucket03 not exists!

5.4 删除Bucket

RemoveBucket(ctx context.Context, bucketName string) error

删除名称为bucketName的bucket，删除之前建议先检查该bucket是否存在，查看下面的demo：

func RemoveBucket(minioClient *minio.Client) {
	bucketName01 := "bucket01"
	isExist, err := minioClient.BucketExists(context.Background(), bucketName01)
	if err != nil {
		fmt.Printf("Check %s err：%s", bucketName01, err.Error())
		return
	}
	if isExist {
		fmt.Printf("%s exists! Start delete....\n", bucketName01)
		// 开始删除逻辑
		err = minioClient.RemoveBucket(context.Background(), bucketName01)
		if err != nil {
			fmt.Printf("Fail to remove %s:%s\n", bucketName01, err.Error())
			return
		}
		fmt.Printf("Success to remove %s\n", bucketName01)
	} else {
		fmt.Printf("%s not exists!\n", bucketName01)
	}
}

输出为：

bucket01 exists! Start delete…

Success to remove bucket01

5.6 展示对象Object

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

展示一个Object中的所有对象，注意返回的是一个channel。在查看下面的demo，请参考之前的内容先上传一些对象：

func ListObjects(minioClient *minio.Client) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	bucketName := "bucket02"
	opts := minio.ListObjectsOptions{
		Prefix:    "头",
		Recursive: true,
	}
	objectCh := minioClient.ListObjects(ctx, bucketName, opts)
	for obj := range objectCh {
		fmt.Printf("Name:%s\tSize:%d\tMD5:%s\tModifiedTime:%s\n",
			obj.Key, obj.Size, obj.ETag, obj.LastModified.Format("2006-01-02 03:04:05"))
	}
}

输出为：

Name:头像.jpg Size:739938 MD5:10bf76e379cd8f381791c6924f33dcd6 ModifiedTime:2023-08-18 05:22:34
注意，在这里Prefix就是所有Object的的前缀。

针对Bucket的操作就到这里，但是minio还提供其余操作，比喻设置tag等等，上面所列举的是常用的一些操作

6. Object操作

6.1 获取Object

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

返回一个数据流对象，注意是一个数据流，所以要写入到一个具体的对象中，详见下面demo的使用：

func GetObjects(minioClient *minio.Client) {
	bucketName := "bucket02"
	objectName := "头像.jpg"
	object, err := minioClient.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{})
	if err != nil {
		fmt.Println(err)
		return
	}
	defer func(object *minio.Object) {
		err := object.Close()
		if err != nil {
			fmt.Println(err)
			return
		}
	}(object)
	localFile, err := os.Create("image/local-file.jpg")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer func(localFile *os.File) {
		err := localFile.Close()
		if err != nil {
			return
		}
	}(localFile)
	if _, err = io.Copy(localFile, object); err != nil {
		fmt.Println(err)
		return
	}
}

注意这个地方文件的写入。

6.2 放入Object

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

将一个文件放入到bucket中，详细见下面的操作，其实之前我们的demo中已经有了这个操作：

func PutObjects(minioClient *minio.Client) {
	bucketName := "bucket02"
	// 检查bucket是否存在
	isExist, err := minioClient.BucketExists(context.Background(), bucketName)
	if err != nil {
		fmt.Printf("Check %s err：%s", bucketName, err.Error())
		return
	}
	if !isExist {
		fmt.Printf("%s not exists!\n", bucketName)
	}
	// 对象信息
	objectName := "头像.jpg"
	filePath := "image"
	contentType := "multipart/form-data"
	fPath := filepath.Join(filePath, objectName)
	// 读取对象流
	fileInfo, err := os.Stat(fPath)
	if err == os.ErrNotExist {
		log.Printf("%s目标文件不存在", fPath)
	}
	f, err := os.Open(fPath)
	if err != nil {
		log.Printf("%s打开目标文件", fPath)
		return
	}
	// 上传文件
	uploadInfo, err := minioClient.PutObject(context.Background(), bucketName,
		objectName, f, fileInfo.Size(),
		minio.PutObjectOptions{ContentType: contentType})
	if err != nil {
		log.Fatalln(err)
		return
	}
	log.Printf("Successfully uploaded %s of size %d\n", objectName, uploadInfo.Size)
}

最后这个文件会被放在你minio服务器上的minio下，你可以去该文件下查看

在这里插入图片描述

6.3 复制Objects

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

将一个文件复制到另一个bucket中，详见下面demo:

func CopyObjects(minioClient *minio.Client) {
	// Source object
	srcOpts := minio.CopySrcOptions{
		Bucket: "bucket02",
		Object: "头像.jpg",
	}
	// Destination object
	dstOpts := minio.CopyDestOptions{
		Bucket: "bucket01",
		Object: "图片.jpg",
	}
	// copy
	uploadInfo, err := minioClient.CopyObject(context.Background(), dstOpts, srcOpts)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println("Successfully copied object:", uploadInfo)
}

输出为：Successfully copied object: {bucket01 图片.jpg 10bf76e379cd8f381791c6924f33dcd6 0 2023-08-18 08:144.773 +0000 UTC 0001-01-01 00:00:00 +0000 UTC }

6.4 状态Objects

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

返回一个object的元数据，demo如下：

func StateObjects(minioClient *minio.Client) {
	ObjInfo, err := minioClient.StatObject(context.Background(), "bucket02", "头像.jpg", minio.StatObjectOptions{})
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Printf("LastModified:%s\tETag:%s\tContentType:%s\tSize:%d\n",
		ObjInfo.LastModified.Format("2006-01-02 03:04:05"),
		ObjInfo.ETag, ObjInfo.ContentType, ObjInfo.Size)
}

输出为：LastModified:2023-08-18 05:22:34 ETag:10bf76e379cd8f381791c6924f33dcd6 ContentType:multipart/form-data Size:739938

6.5 删除Object

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

删除一个object，注意下面demo：

func RemoveObject(minioClient *minio.Client) {
	opts := minio.RemoveObjectOptions{}
	err := minioClient.RemoveObject(context.Background(), "bucket01", "图片.jpg", opts)
	if err != nil {
		fmt.Println(err)
		return
	}
}

6.6 批量删除Object

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

批量删除一个bucket中的object，关键就是构造这里的objectsCh，详细见demo：

func RemoveObjects(minioClient *minio.Client) {
	objectsCh := make(chan minio.ObjectInfo)
	// 注意一般不要自己来构造，直接选择从bucket中查询，查询到的对象放入objectsCh
	for object := range minioClient.ListObjects(context.Background(), "bucket02", minio.ListObjectsOptions{}) {
		if object.Key == "头像.jpg" {
			objectsCh <- object
		}
	}
	defer close(objectsCh)
	// 删除
	for rErr := range minioClient.RemoveObjects(context.Background(), "bucket02", objectsCh, minio.RemoveObjectsOptions{}) {
		fmt.Println("Delete err:", rErr.Err.Error())
	}
}

6.7 上传大对象Object

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

该demo如下：

func UploadLargeFileObjects(minioClient *minio.Client) {
	uploadInfo, err := minioClient.FPutObject(context.Background(), "bucket02", "test.csv", "data", minio.PutObjectOptions{
		ContentType: "application/csv",
	})
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println("Successfully uploaded object: ", uploadInfo)
}

在MinIO中,PutObject和FPutObject主要有以下几点区别:

  • 操作对象方式不同:
    • PutObject上传对象采用单个对象上传方式,一次请求上传一个对象。
    • FPutObject上传对象采用分片上传方式,可以在多个请求中上传同一个对象。
  • 适用场景不同:
    • PutObject适用于小对象的上传。
    • FPutObject适用于大对象的上传,可以支持超过5GB的对象上传。
  • 上传方式不同:
    • PutObject直接上传对象。
    • FPutObject需要首先调用InitiateMultipartUpload初始化分片上传,然后调用UploadPart上传每个分片,最后调用CompleteMultipartUpload完成上传。
  • 错误处理不同:
    • PutObject上传错误需要重新上传整个对象。
    • FPutObject上传错误只需要重新上传出错的分片。
  • 上传事务不同:
    • PutObject上传具有原子性,一个对象要么完全上传,要么失败。
    • FPutObject上传可以暂停和恢复,但多个分片上传完成后才视为成功。

所以简单来说,对于小对象可以直接使用PutObject,对于大对象建议使用FPutObject分片上传。

6.8 下载大对象

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

下载大文件，详见下面demo:

func DownloadLargeFileObjects(minioClient *minio.Client) {
	err := minioClient.FGetObject(context.Background(), "bucket02", "test.csv", "/tmp/myobject", minio.GetObjectOptions{})
	if err != nil {
		fmt.Println(err)
		return
	}
}

基本上的操作就是这样，当然这里还可以需要设置一些策略设置就不在这里详讲了，可以去官网查看.

完整代码：

package main
import (
	"context"
	"fmt"
	"github.com/minio/minio-go/v7"
	"github.com/minio/minio-go/v7/pkg/credentials"
	"io"
	"log"
	"os"
	"path/filepath"
)
func InitMinioClient() *minio.Client {
	// 基本的配置信息
	endpoint := "172.16.59.129:9000"
	accessKeyID := "6b6U1MlseU8h9dDkACNj"
	secretAccessKey := "Hf6NSEHjXwHiApoymYR0yktNUkbZwt3MYYRmXOgT"
	// 初始化一个minio客户端对象
	minioClient, err := minio.New(endpoint, &minio.Options{
		Creds: credentials.NewStaticV4(accessKeyID, secretAccessKey, ""),
	})
	if err != nil {
		log.Fatalf("初始化MinioClient错误：%s", err.Error())
	}
	return minioClient
}
func main() {
	// 创建客户端
	minioClient := InitMinioClient()
	// Make a new bucket called mymusic.
	// bucketName := "mypic"
	//ctx := context.Background()
	//err := minioClient.MakeBucket(ctx, bucketName, minio.MakeBucketOptions{})
	//if err != nil {
	//	// Check to see if we already own this bucket (which happens if you run this twice)
	//	exists, errBucketExists := minioClient.BucketExists(ctx, bucketName)
	//	if errBucketExists == nil && exists {
	//		log.Printf("We already own %s\n", bucketName)
	//	} else {
	//		log.Fatalln(err)
	//	}
	//} else {
	//	log.Printf("Successfully created %s\n", bucketName)
	//}
	//
	 Upload the zip file
	//objectName := "头像.jpg"
	//filePath := "image"
	//contentType := "multipart/form-data"
	//fPath := filepath.Join(filePath, objectName)
	//fileInfo, err := os.Stat(fPath)
	//if err == os.ErrNotExist {
	//	log.Printf("%s目标文件不存在", fPath)
	//}
	//
	//f, err := os.Open(fPath)
	//if err != nil {
	//	return
	//}
	//
	//uploadInfo, err := minioClient.PutObject(ctx, bucketName, objectName, f, fileInfo.Size(), minio.PutObjectOptions{ContentType: contentType})
	//if err != nil {
	//	log.Fatalln(err)
	//}
	//
	//log.Printf("Successfully uploaded %s of size %d\n", objectName, uploadInfo.Size)
	// ListBuckets(minioClient)
	//CheckBuckets(minioClient)
	//RemoveBucket(minioClient)
	//UploadObjToBucket(minioClient)
	//ListObjects(minioClient)
	//GetObjects(minioClient)
	//CopyObjects(minioClient)
	//StateObjects(minioClient)
	//RemoveObject(minioClient)
	RemoveObjects(minioClient)
}
func ListBuckets(minioClient *minio.Client) {
	bucketInfos, err := minioClient.ListBuckets(context.Background())
	if err != nil {
		fmt.Println("List Buckets err：", err.Error())
		return
	}
	for index, bucketInfo := range bucketInfos {
		fmt.Printf("List Bucket No {%d}----filename{%s}-----createTime{%s}\n", index+1, bucketInfo.Name, bucketInfo.CreationDate.Format("2006-01-02 15:04:05"))
	}
}
func CheckBuckets(minioClient *minio.Client) {
	bucketName01 := "bucket01"
	bucketName02 := "bucket03"
	isExist, err := minioClient.BucketExists(context.Background(), bucketName01)
	if err != nil {
		fmt.Printf("Check %s err：%s", bucketName01, err.Error())
		return
	}
	if isExist {
		fmt.Printf("%s exists!\n", bucketName01)
	} else {
		fmt.Printf("%s not exists!\n", bucketName01)
	}
	isExist, err = minioClient.BucketExists(context.Background(), bucketName02)
	if err != nil {
		fmt.Printf("Check %s err：%s", bucketName02, err.Error())
		return
	}
	if isExist {
		fmt.Printf("%s exists!\n", bucketName02)
	} else {
		fmt.Printf("%s not exists!\n", bucketName02)
	}
}
func RemoveBucket(minioClient *minio.Client) {
	bucketName01 := "bucket01"
	isExist, err := minioClient.BucketExists(context.Background(), bucketName01)
	if err != nil {
		fmt.Printf("Check %s err：%s", bucketName01, err.Error())
		return
	}
	if isExist {
		fmt.Printf("%s exists! Start delete....\n", bucketName01)
		// 开始删除逻辑
		err = minioClient.RemoveBucket(context.Background(), bucketName01)
		if err != nil {
			fmt.Printf("Fail to remove %s:%s\n", bucketName01, err.Error())
			return
		}
		fmt.Printf("Success to remove %s\n", bucketName01)
	} else {
		fmt.Printf("%s not exists!\n", bucketName01)
	}
}
func ListObjects(minioClient *minio.Client) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	bucketName := "bucket02"
	opts := minio.ListObjectsOptions{
		Prefix:    "头",
		Recursive: true,
	}
	objectCh := minioClient.ListObjects(ctx, bucketName, opts)
	for obj := range objectCh {
		fmt.Printf("Name:%s\tSize:%d\tMD5:%s\tModifiedTime:%s\n",
			obj.Key, obj.Size, obj.ETag, obj.LastModified.Format("2006-01-02 03:04:05"))
	}
}
func GetObjects(minioClient *minio.Client) {
	bucketName := "bucket02"
	objectName := "头像.jpg"
	object, err := minioClient.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{})
	if err != nil {
		fmt.Println(err)
		return
	}
	defer func(object *minio.Object) {
		err := object.Close()
		if err != nil {
			fmt.Println(err)
			return
		}
	}(object)
	localFile, err := os.Create("image/local-file.jpg")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer func(localFile *os.File) {
		err := localFile.Close()
		if err != nil {
			return
		}
	}(localFile)
	if _, err = io.Copy(localFile, object); err != nil {
		fmt.Println(err)
		return
	}
}
func PutObjects(minioClient *minio.Client) {
	bucketName := "bucket02"
	// 检查bucket是否存在
	isExist, err := minioClient.BucketExists(context.Background(), bucketName)
	if err != nil {
		fmt.Printf("Check %s err：%s", bucketName, err.Error())
		return
	}
	if !isExist {
		fmt.Printf("%s not exists!\n", bucketName)
	}
	// 对象信息
	objectName := "头像.jpg"
	filePath := "image"
	contentType := "multipart/form-data"
	fPath := filepath.Join(filePath, objectName)
	// 读取对象流
	fileInfo, err := os.Stat(fPath)
	if err == os.ErrNotExist {
		log.Printf("%s目标文件不存在", fPath)
	}
	f, err := os.Open(fPath)
	if err != nil {
		log.Printf("%s打开目标文件", fPath)
		return
	}
	// 上传文件
	uploadInfo, err := minioClient.PutObject(context.Background(), bucketName,
		objectName, f, fileInfo.Size(),
		minio.PutObjectOptions{ContentType: contentType})
	if err != nil {
		log.Fatalln(err)
		return
	}
	log.Printf("Successfully uploaded %s of size %d\n", objectName, uploadInfo.Size)
}
func CopyObjects(minioClient *minio.Client) {
	// Source object
	srcOpts := minio.CopySrcOptions{
		Bucket: "bucket02",
		Object: "头像.jpg",
	}
	// Destination object
	dstOpts := minio.CopyDestOptions{
		Bucket: "bucket01",
		Object: "图片.jpg",
	}
	// copy
	uploadInfo, err := minioClient.CopyObject(context.Background(), dstOpts, srcOpts)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println("Successfully copied object:", uploadInfo)
}
func StateObjects(minioClient *minio.Client) {
	ObjInfo, err := minioClient.StatObject(context.Background(), "bucket02", "头像.jpg", minio.StatObjectOptions{})
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Printf("LastModified:%s\tETag:%s\tContentType:%s\tSize:%d\n",
		ObjInfo.LastModified.Format("2006-01-02 03:04:05"),
		ObjInfo.ETag, ObjInfo.ContentType, ObjInfo.Size)
}
func RemoveObject(minioClient *minio.Client) {
	opts := minio.RemoveObjectOptions{}
	err := minioClient.RemoveObject(context.Background(), "bucket01", "图片.jpg", opts)
	if err != nil {
		fmt.Println(err)
		return
	}
}
func RemoveObjects(minioClient *minio.Client) {
	objectsCh := make(chan minio.ObjectInfo)
	// 注意一般不要自己来构造，直接选择从bucket中查询，查询到的对象放入objectsCh
	for object := range minioClient.ListObjects(context.Background(), "bucket02", minio.ListObjectsOptions{}) {
		if object.Key == "头像.jpg" {
			objectsCh <- object
		}
	}
	defer close(objectsCh)
	// 删除
	for rErr := range minioClient.RemoveObjects(context.Background(), "bucket02", objectsCh, minio.RemoveObjectsOptions{}) {
		fmt.Println("Delete err:", rErr.Err.Error())
	}
}
func UploadLargeFileObjects(minioClient *minio.Client) {
	uploadInfo, err := minioClient.FPutObject(context.Background(), "bucket02", "test.csv", "data", minio.PutObjectOptions{
		ContentType: "application/csv",
	})
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println("Successfully uploaded object: ", uploadInfo)
}
func DownloadLargeFileObjects(minioClient *minio.Client) {
	err := minioClient.FGetObject(context.Background(), "bucket02", "test.csv", "/tmp/myobject", minio.GetObjectOptions{})
	if err != nil {
		fmt.Println(err)
		return
	}
}

到此这篇关于Golang使用MinIO的文章就介绍到这了,更多相关Golang使用MinIO内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

相关文章

  • Golang编程实现生成n个从a到b不重复随机数的方法

    Golang编程实现生成n个从a到b不重复随机数的方法

    这篇文章主要介绍了Golang编程实现生成n个从a到b不重复随机数的方法,结合实例形式分析了Go语言字符串操作及随机数生成的相关操作技巧,需要的朋友可以参考下
    2017-01-01
  • Go语言中的Slice学习总结

    Go语言中的Slice学习总结

    这篇文章主要介绍了Go语言中的Slice学习总结,本文讲解了Slice的定义、Slice的长度和容量、Slice是引用类型、Slice引用传递发生“意外”等内容,需要的朋友可以参考下
    2014-11-11
  • Go调度器学习之系统调用详解

    Go调度器学习之系统调用详解

    这篇文章肿，将以一个简单的文件打开的系统调用，来分析一下Go调度器在系统调用时做了什么。文中的示例代码讲解详细，需要的可以参考一下
    2023-04-04
  • Go结构体从基础到应用深度探索

    Go结构体从基础到应用深度探索

    本文深入探讨了结构体的定义、类型、字面量表示和使用方法,旨在为读者呈现Go结构体的全面视角,通过结构体,开发者可以实现更加模块化、高效的代码设计,这篇文章旨在为您提供关于结构体的深入理解,助您更好地利用Go语言的强大功能
    2023-10-10
  • golang语言实现的文件上传与文件下载功能示例

    golang语言实现的文件上传与文件下载功能示例

    这篇文章主要介绍了golang语言实现的文件上传与文件下载功能,结合实例形式分析了Go语言实现的文件传输相关操作技巧,需要的朋友可以参考下
    2020-02-02
  • golang elasticsearch Client的使用详解

    golang elasticsearch Client的使用详解

    这篇文章主要介绍了golang elasticsearch Client的使用详解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
    2021-05-05
  • Go设计模式之状态模式图文详解

    Go设计模式之状态模式图文详解

    状态模式是一种行为设计模式, 让你能在一个对象的内部状态变化时改变其行为, 使其看上去就像改变了自身所属的类一样,本文将通过一些图片来给大家详细的介绍一下Go的状态模式,需要的朋友可以参考下
    2023-08-08
  • Gin框架之参数绑定的实现

    Gin框架之参数绑定的实现

    为了能够更方便的获取请求相关参数，提高开发效率，本文主要介绍了Gin框架之参数绑定的实现，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2021-12-12
  • Go语言带缓冲的通道的使用

    Go语言带缓冲的通道的使用

    Go语言中有缓冲的通道是一种在被接收前能存储一个或者多个值的通道,本文就来介绍一下Go语言带缓冲的通道的使用,具有一定的参考价值,感兴趣的可以了解一下
    2024-01-01
  • 使用Go语言实现微信公众平台

    使用Go语言实现微信公众平台

    这篇文章主要介绍了使用Go语言实现微信公众平台，虽然不是全部代码，但是也是给我们提供了一个非常好的思路,需要的朋友可以参考下
    2015-01-01

最新评论