Golang使用MinIO的方案詳解
更新時間：2023年08月19日 09:48:20 作者：HumbleSwage
這篇文章主要介紹了Golang使用MinIO的過程，本文給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下
最近在使用Golang做了一個網(wǎng)盤項目（學習），文件存儲一直保存在本地（各廠商提供的oss貴），所以就在思考怎么來處理這些文件，類似的方案很對hdfs、fastdfs，但這其中MinIO是最近幾年比較火熱的一個項目，所以嘗試使用這個試一試。
1、MinIO的安裝
MinIO的安裝特別簡單，大家可以前去官網(wǎng)按照步驟完成，注意以下幾點即可
- 注意你服務器是amd還是arm架構
- 注意你自己的網(wǎng)絡
- 確保你按照官網(wǎng)的命令開啟了minio服務
minio server ~/minio --console-address :9090
目前不要隨便亂修改，按照原始的方案
2、創(chuàng)建Golang項目
mkdir minio-api cd minio-api go mod init v1
3、Goland打開項目構建一個上傳文件demo
創(chuàng)建一個main.go，在這個函數(shù)中我們首先創(chuàng)建一個用于初始化MinIOClient的函數(shù)，該函數(shù)細節(jié)如下：
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的創(chuàng)建如下圖：
然后我們構建一個main函數(shù)，在這個main函數(shù)中，我們首先調(diào)用初始化客戶端的函數(shù)InitMinioClient，然后我們在main實現(xiàn)一個簡單的上傳文件的demo
func main() {
// 創(chuàng)建客戶端
minioClient := InitMinioClient()
// bucket名稱
bucketName := "mypic"
ctx := context.Background()
// 創(chuàng)建這個bucket
err := minioClient.MakeBucket(ctx, bucketName, minio.MakeBucketOptions{})
if err != nil {
// 檢測這個bucket是否已經(jīng)存在
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)
}
上傳文件即成功，然后打開網(wǎng)頁頁面刷新，出現(xiàn)下面頁面即可，同時你打開你的服務器可以發(fā)現(xiàn)你上傳的文件。
觀察上面的代碼，至少包括三個API，包括創(chuàng)建Bucket、檢測Bucket是否存在、上傳文件到指定的Bucket。為了更好的研究這些API，現(xiàn)在我從Bucket開始研究一下常用的API。
4.創(chuàng)建客戶端對象
API接口
New(endpoint string, opts *Options) (*Client, error)
初步觀察這個接口，在結合我們上面的示例，可以發(fā)現(xiàn)：
- endpoint：目前存儲地址（127.0.0.1:9000），當然這里需要根據(jù)自身開啟的minio服務所在的位置和服務端口。
- opts：這個是一個minio.Options對象，然后我們來具體了解一哈這個對象有哪些常用的屬性（注意這些屬性的類）：
- Creds：存儲的一個身份信任
- Secure：API的請求方式（HTTP/HTTPS）
- 完整的一個創(chuàng)建Client的代碼（可以根據(jù)自身需要再改造）
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
}你自己可以嘗試：創(chuàng)建一個bucket01和bucket02
5.Bucket的基本操作
5.1 創(chuàng)建Bucket
MakeBucket(ctx context.Context, bucketName string, opts MakeBucketOptions)
前兩個參數(shù)不作過多的介紹，非常的清晰（所謂的BuketName，你可以簡單理解為就是你文件保存的文件夾），在這里我們詳細得介紹一哈MakeBucketOptions（minio.MakeBucketOptions），其主要是用于指定Bucket的一些選項比如說 Region （這個地方的Region表示在哪里創(chuàng)建你的Bucket，默認為 us-east-1 ，其它的一些選項可以參考官網(wǎng)文檔，在這里需要注意，如果你是自己服務器搭建，而不是使用他所提供的存儲服務，其實你是不用指定這個，就默認值問題也不大），一個完整的示例如下（確保你事先已經(jīng)有這樣的 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的內(nèi)容移到新建的一個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，請參考之前的內(nèi)容先上傳一些對象：
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)
返回一個數(shù)據(jù)流對象，注意是一個數(shù)據(jù)流，所以要寫入到一個具體的對象中，詳見下面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中已經(jīng)有了這個操作：
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 狀態(tài)Objects
StatObject(ctx context.Context, bucketName, objectName string, opts StatObjectOptions) (ObjectInfo, error)
返回一個object的元數(shù)據(jù)，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主要有以下幾點區(qū)別:
- 操作對象方式不同:
- PutObject上傳對象采用單個對象上傳方式,一次請求上傳一個對象。
- FPutObject上傳對象采用分片上傳方式,可以在多個請求中上傳同一個對象。
- 適用場景不同:
- PutObject適用于小對象的上傳。
- FPutObject適用于大對象的上傳,可以支持超過5GB的對象上傳。
- 上傳方式不同:
- PutObject直接上傳對象。
- FPutObject需要首先調(diào)用InitiateMultipartUpload初始化分片上傳,然后調(diào)用UploadPart上傳每個分片,最后調(diào)用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
}
}基本上的操作就是這樣，當然這里還可以需要設置一些策略設置就不在這里詳講了，可以去官網(wǎng)查看.
完整代碼：
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() {
// 創(chuàng)建客戶端
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內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
利用GoLang?Fiber進行高性能Web開發(fā)實例詳解
這篇文章主要為大家介紹了利用GoLang?Fiber進行高性能Web開發(fā)實例詳解,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進步,早日升職加薪2024-01-01
這篇文章主要介紹了Go語言struct類型詳解,struct是一種數(shù)據(jù)類型,可以用來定義自己想的數(shù)據(jù)類型,需要的朋友可以參考下2014-10-10
這篇文章主要介紹了golang 實現(xiàn)兩個結構體復制字段，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2021-04-04
Go語言性能監(jiān)控和調(diào)優(yōu)的工具和方法
本文介紹了Go語言性能監(jiān)控和調(diào)優(yōu)的工具和方法,包括?pprof、expvar?和?trace?等工具的使用方法和注意事項,以及性能調(diào)優(yōu)的一些常見方法,如減少內(nèi)存分配、避免頻繁的垃圾回收、避免過度查詢數(shù)據(jù)庫等,針對不同的程序,應該根據(jù)實際情況采用不同的優(yōu)化方法2024-01-01
這篇文章主要為大家詳細介紹了如何使用Go語言實現(xiàn)發(fā)送微信群消息,文中的示例代碼講解詳細,感興趣的小伙伴可以跟隨小編一起學習一下2024-01-01
結構體類型可以用來保存不同類型的數(shù)據(jù)，也可以通過方法的形式來聲明它的行為。本文將介紹go語言中的結構體和方法，以及“繼承”的實現(xiàn)方法2021-09-09
面向對象中的多態(tài)（Polymorphism）是指一個對象可以具有多種不同的形態(tài)或表現(xiàn)方式，本文將通過一些簡單的示例為大家講解一下多態(tài)的實現(xiàn)，需要的可以參考下2023-07-07
這篇文章主要為大家介紹了GoFrame?ORM原生方法操作示例，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-06-06
這篇文章主要給大家介紹了關于golang實戰(zhàn)之truncate日志文件的相關資料，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2018-07-07
Go語言結合grpc和protobuf實現(xiàn)去中心化的聊天室
這篇文章主要為大家詳細介紹了Go語言如何結合grpc和protobuf實現(xiàn)去中心化的聊天室,文中的示例代碼講解詳細,有需要的小伙伴可以跟隨小編一起學習一下2024-03-03