Golang 上传文件到 MinIO？别瞎折腾了，这 5 个库拿去用

原创

用户11680974

发布于 2025-10-29 18:48:17

10600

代码可运行

运行总次数：0

代码可运行

米娜桑，日常开发里，有谁是没有跟文件上传下载打交道的？图片、视频、日志、备份……这些往哪儿搁？一个很不错的选择就是对象存储，而 MinIO 就是其中的明星选手。

MinIO 是一个用 Go 写的、开源的、能自己部署的对象存储服务，API 完全兼容亚马逊 S3，可以算是自己私有的阿里云 OSS 或者亚马逊 S3，数据攥在自己手里，美滋滋。

不过，在享受 MinIO 带来的便利之前，得先把它跑起来。官方文档要求输入一大堆 docker run 命令，挂载一堆目录，配置一堆环境变量……要是对 Docker 不熟，那可真有的折腾了。什么端口冲突、数据持久化、网络配置，分分钟就是从入门到放弃。

这时候就可以考虑开发神器 ServBay 了，它除了支持各种常用开发语言 —— Python、Java、Golang，还有常用SQL和NoSQL数据库，它还支持 MinIO 这种常用的服务。用户就不需要跟 Docker 命令死磕，也不用管什么复杂的依赖配置，在 ServBay 面板上点几下，一个热乎乎的 MinIO 服务就跑起来了，省下来的时间摸摸鱼、喝喝茶，爽歪歪。

用 ServBay 一键搞定了 MinIO 服务后，万事俱备，只欠代码。那用 Go 把文件传到 MinIO，有哪些好用的库？我给你挑了 5 个，各有千秋，任君选择。

MinIO 官方 Go SDK (minio-go)

这可是亲儿子，MinIO 官方自己维护的库。兼容性、功能支持肯定是最好的，用起来也最符合直觉。如果是没啥特殊癖好，就用它，准没错。

代码示例

package main

import (
        "context"
        "log"

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

func main() {
        ctx := context.Background()
        // MinIO 配置
        minioHost := "127.0.0.1:9000"
        accessKeyID := "minioadmin" // 默认的 admin 账号
        secretAccessKey := "minioadmin" // 默认的 admin 密码
        useSSL := false // 本地开发环境，一般不用 SSL, 如果你是用ServBay，本地开发环境也是能用SSL的

        // 初始化 MinIO 客户端
        minioClient, err := minio.New(minioHost, &minio.Options{
                Creds:  credentials.NewStaticV4(accessKeyID, secretAccessKey, ""),
                Secure: useSSL,
        })
        if err != nil {
                log.Fatalln("初始化 MinIO 客户端失败:", err)
        }

        // 准备上传
        bucketName := "learning-go"
        objectName := "my-first-object.txt"
        filePath := "./hello.txt" // 确保这个文件存在

        // 检查 bucket 是否存在，不存在就创建一个
        exists, err := minioClient.BucketExists(ctx, bucketName)
        if err != nil {
                log.Fatalln("检查存储桶失败:", err)
        }
        if !exists {
                err = minioClient.MakeBucket(ctx, bucketName, minio.MakeBucketOptions{})
                if err != nil {
                        log.Fatalln("创建存储桶失败:", err)
                }
                log.Printf("成功创建存储桶: %s\n", bucketName)
        }

        // 上传文件
        uploadInfo, err := minioClient.FPutObject(ctx, bucketName, objectName, filePath, minio.PutObjectOptions{})
        if err != nil {
                log.Fatalln("上传文件失败:", err)
        }

        log.Printf("文件上传成功！对象名: %s, 大小: %d 字节\n", objectName, uploadInfo.Size)
}

代码特点：逻辑清晰，FPutObject 直接从文件路径上传，非常方便。官方库嘛，就是这么贴心。

AWS SDK for Go (aws-sdk-go)

既然 MinIO 兼容 S3，那我用 AWS 的官方 SDK 操作它，合情合理吧？

那必须的！很多老项目可能已经集成了 AWS 的 SDK，迁移到 MinIO 或者混合使用时，用这个库就完全不用改代码，平滑过渡。

代码示例：

package main

import (
        "log"
        "os"

        "github.com/aws/aws-sdk-go/aws"
        "github.com/aws/aws-sdk-go/aws/credentials"
        "github.com/aws/aws-sdk-go/aws/session"
        "github.com/aws/aws-sdk-go/service/s3/s3manager"
)

func main() {
        // MinIO 配置
        minioEndpoint := "http://127.0.0.1:9000" 
        accessKey := "minioadmin"
        secretKey := "minioadmin"
        region := "us-east-1" // MinIO 不关心 region，但 AWS SDK 需要，随便填一个
        bucket := "go-aws-sdk-bucket"
        localFilePath := "./hello.txt" // 确保这个文件存在
        objectKey := "greeting.txt"

        // 创建 AWS session
        sess, err := session.NewSession(&aws.Config{
                Credentials:      credentials.NewStaticCredentials(accessKey, secretKey, ""),
                Endpoint:         aws.String(minioEndpoint),
                Region:           aws.String(region),
                S3ForcePathStyle: aws.Bool(true), // 这个对 MinIO 很重要，必须是 true
        })
        if err != nil {
                log.Fatalf("创建 AWS session 失败: %v", err)
        }

        // 打开本地文件
        file, err := os.Open(localFilePath)
        if err != nil {
                log.Fatalf("打开文件失败: %v", err)
        }
        defer file.Close()

        // 创建一个上传器
        uploader := s3manager.NewUploader(sess)

        // 执行上传
        _, err = uploader.Upload(&s3manager.UploadInput{
                Bucket: aws.String(bucket),
                Key:    aws.String(objectKey),
                Body:   file,
        })
        if err != nil {
                log.Fatalf("上传文件到 MinIO 失败: %v", err)
        }

        log.Printf("文件已通过 AWS SDK 成功上传到: %s/%s\n", bucket, objectKey)
}

代码特点：s3manager 提供了高级封装，能自动处理大文件的分片上传，很省心。记得 S3ForcePathStyle 一定要设成 true。

Go Cloud (gocloud.dev)

如果想写出“与平台无关”的代码，今天用 MinIO，明天想换成 Google Cloud Storage，后天又想试试 Azure Blob Storage，而且不想改业务逻辑代码，那 Go Cloud 就是最佳选择，它提供了一套统一的 blob (Binary Large Object) 操作接口。

代码示例：

package main

import (
        "context"
        "fmt"
        "log"
        "os"

        "gocloud.dev/blob"
        _ "gocloud.dev/blob/s3blob" // 别忘了匿名导入 S3 驱动
)

func main() {
        // MinIO 配置
        minioHost := "127.0.0.1:9000"
        accessKey := "minioadmin"
        secretKey := "minioadmin"
        bucketName := "gocloud-bucket"
        localFile := "./hello.txt"
        objectKey := "cloud-file.txt"

        // 用 URL 的方式配置连接，这是 Go Cloud 的特色
        // 注意参数：endpoint, disableSSL, s3ForcePathStyle
        bucketURL := fmt.Sprintf("s3://%s?endpoint=%s&access_key_id=%s&secret_access_key=%s&disableSSL=true&s3ForcePathStyle=true",
                bucketName, minioHost, accessKey, secretKey)

        ctx := context.Background()
        // 打开一个 bucket
        b, err := blob.OpenBucket(ctx, bucketURL)
        if err != nil {
                log.Fatalf("打开 bucket 失败: %v", err)
        }
        defer b.Close()

        // 读取本地文件内容
        data, err := os.ReadFile(localFile)
        if err != nil {
                log.Fatalf("读取文件失败: %v", err)
        }

        // 写入对象存储
        err = b.WriteAll(ctx, objectKey, data, nil)
        if err != nil {
                log.Fatalf("上传文件失败: %v", err)
        }

        log.Printf("文件已通过 Go Cloud 成功上传到: %s/%s\n", bucketName, objectKey)
}

代码特点：核心代码就 blob.OpenBucket 和 b.WriteAll 两步，非常抽象。那个长长的 bucketURL 就是配置的关键，把所有参数都塞进去了。

go-storage

go-storage 是另一个存储抽象库，理念和 Go Cloud 类似，但出自不同的社区。它的目标也是提供一套统一的 API 来操作各种存储服务。如果你觉得 Go Cloud 不合胃口，可以试试这个。

代码示例：

package main

import (
        "context"
        "fmt"
        "log"
        "os"

        "github.com/beyondstorage/go-storage/v5/services"
        "github.com/beyondstorage/go-storage/v5/types"
)

func main() {
        // MinIO 配置
        minioHost := "127.0.0.1:9000"
        accessKey := "minioadmin"
        secretKey := "minioadmin"
        bucketName := "go-storage-bucket"
        filePath := "./hello.txt"
        objectName := "storage-api-file.txt"

        // 同样是连接字符串的玩法
        connStr := fmt.Sprintf("s3://%s@%s?credential=hmac:%s:%s&endpoint=http://%s",
                bucketName, "us-east-1", accessKey, secretKey, minioHost)

        // 从字符串创建存储服务实例
        store, err := services.NewStoragerFromString(connStr)
        if err != nil {
                log.Fatalf("创建 storager 失败: %v", err)
        }

        // 打开文件
        file, err := os.Open(filePath)
        if err != nil {
                log.Fatalf("打开文件失败: %v", err)
        }
        defer file.Close()

        // 获取文件信息，主要是为了拿到大小
        stat, _ := file.Stat()
        fileSize := stat.Size()

        // 执行写入操作
        _, err = store.Write(context.Background(), objectName, file, fileSize, types.WithForcePair(true))
        if err != nil {
                log.Fatalf("写入对象失败: %v", err)
        }

        log.Printf("文件已通过 go-storage 成功上传到: %s/%s\n", bucketName, objectName)
}

代码特点：API 风格和 Go Cloud 不太一样，连接字符串的格式也不同。store.Write 需要传入文件大小，这点要注意。

直接使用 AWS SDK for Go 的底层 S3 客户端

前面我们用了 s3manager，那是高级封装。但有时候需要更精细的控制，比如设置特定的元数据、ACL 等，这时候就可以直接用底层的 s3 客户端。

代码示例：

package main

import (
        "log"
        "os"

        "github.com/aws/aws-sdk-go/aws"
        "github.com/aws/aws-sdk-go/aws/credentials"
        "github.comcom/aws/aws-sdk-go/aws/session"
        "github.com/aws/aws-sdk-go/service/s3"
)

func main() {
        // MinIO 配置
        minioEndpoint := "http://127.0.0.1:9000"
        accessKey := "minioadmin"
        secretKey := "minioadmin"
        region := "us-east-1"
        bucket := "low-level-bucket"
        localFilePath := "./hello.txt"
        objectKey := "detail-control.txt"

        // 配置和之前一样
        awsConfig := &aws.Config{
                Credentials:      credentials.NewStaticCredentials(accessKey, secretKey, ""),
                Endpoint:         aws.String(minioEndpoint),
                Region:           aws.String(region),
                S3ForcePathStyle: aws.Bool(true),
        }

        sess := session.Must(session.NewSession(awsConfig))

        // 直接创建 S3 服务客户端，而不是 s3manager
        s3Client := s3.New(sess)

        file, err := os.Open(localFilePath)
        if err != nil {
                log.Fatalf("打开文件失败: %v", err)
        }
        defer file.Close()

        // 直接调用 PutObject API
        _, err = s3Client.PutObject(&s3.PutObjectInput{
                Bucket: aws.String(bucket),
                Key:    aws.String(objectKey),
                Body:   file,
                // 在这里可以设置更多参数，比如 ACL, ContentType 等
                // ACL:    aws.String("public-read"),
        })

        if err != nil {
                log.Fatalf("PutObject 失败: %v", err)
        }

        log.Printf("文件已通过底层 S3 客户端成功上传到: %s/%s\n", bucket, objectKey)
}

代码特点：这个方法给了你最大的灵活性，PutObjectInput 结构体里有很多字段可以配置，适合需要深度定制上传行为的场景。

总结一下

库	优点	适合场景
minio-go	官方支持，功能最全，API 直观	新项目，或只和 MinIO 打交道的项目
aws-sdk-go (s3manager)	社区庞大，自动处理大文件，S3 生态通用	已在使用 AWS SDK 的项目，需要处理大文件上传
gocloud.dev	高度抽象，平台无关，代码可移植性强	需要兼容多种对象存储，不想被厂商绑定的架构
go-storage	另一个优秀的抽象库，API 设计有特色	Go Cloud 的替代品，看个人编码喜好
aws-sdk-go (s3 client)	控制粒度最细，灵活性最高	需要精细控制上传参数（元数据、权限等）的场景

选择哪个库，没有绝对的好坏，看项目需求和个人偏好。

但无论是选择哪个库，一个稳定、易于管理的 MinIO 环境都是你施展拳脚的前提。再次安利一下 ServBay，它能把搭建环境的麻烦事变得更加轻松便利，代码都比同事写得快很多。

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

#ServBay

登录后参与评论

0 条评论

热度