Golang使用minio替代文件系统的实战教程

// 配置客户端的三个步骤
// 1. accesskey and secretkey : 创建minio集群后获取访问key和密钥key
// 2. endpoint : minio cluster 访问地址
// 3. usessl : 是否需要ssl 检查 ? (true or false)
import  "github.com/minio/minio-go/v7"

func getminioclient(accesskey string, secretkey string, endpoint string, 
                     usessl bool)(*minio.client, error) {
 // context you want to use
 context := context.background()
 minioclient, err := getminioclient(accesskey, secretkey, endpoint, usessl)
 return minioclient, err
}

set minio_notify_webhook_enable_primary=”on”
set minio_notify_webhook_endpoint_primary=”endpoint”

package main

import (
    "context"
    "fmt"
    "log"

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

// createbucket创建minio存储桶并配置桶通知
func createbucket(bucketname, marn string, minioclient *minio.client) error {
    // 1. 创建存储桶
    ctx := context.background()
    err := minioclient.makebucket(ctx, bucketname, minio.makebucketoptions{})
    if err!= nil {
        // 检查存储桶是否已存在，如果是因为已存在导致的错误则忽略
        exists, errbucketexists := minioclient.bucketexists(ctx, bucketname)
        if errbucketexists == nil && exists {
            fmt.printf("存储桶 %s 已存在，无需重复创建\n", bucketname)
            return nil
        }
        return fmt.errorf("创建存储桶失败: %v", err)
    }
    fmt.printf("存储桶 %s 创建成功\n", bucketname)

    // 2. 配置桶通知
    arn, err := notification.newarnfromstring(marn)
    if err!= nil {
        return fmt.errorf("解析arn失败: %v", err)
    }

    config := notification.newconfig(arn)
    config.addevents(
        notification.objectcreatedall,
        notification.objectremovedall,
        notification.objectaccessedall,
    )

    notificationconfig := notification.configuration{}
    notificationconfig.addqueue(config)

    err = minioclient.setbucketnotification(ctx, bucketname, &notificationconfig)
    if err!= nil {
        return fmt.errorf("设置存储桶通知失败: %v", err)
    }
    fmt.printf("存储桶 %s 的通知配置成功\n", bucketname)

    return nil
}

func main() {
    // minio服务端的访问端点、访问密钥和秘密密钥
    endpoint := "your_minio_endpoint"
    accesskey := "your_access_key"
    secretkey := "your_secret_key"
    bucketname := "your_bucket_name"
    marn := "your_webhook_arn"

    // 创建minio客户端对象
    minioclient, err := minio.new(endpoint, &minio.options{
        credentials: minio.credentials{
            accesskey: accesskey,
            secretkey: secretkey,
        },
    })
    if err!= nil {
        log.fatalf("创建minio客户端失败: %v", err)
    }

    // 调用创建存储桶并配置通知的函数
    err = createbucket(bucketname, marn, minioclient)
    if err!= nil {
        log.fatalf("执行创建存储桶及配置通知操作失败: %v", err)
    }
}

func readobject(bucketname string, filepath string)([]byte, error) {
     contentbuffer, err := minioclient.getobject(context, bucketname, filepath, minio.getobjectoptions{})
     if err != nil {
       return nil, err
     }

     // read the content from the buffer
     contentbytes := new(bytes.buffer)
     if _, err := io.copy(contentbytes, contentbuffer); err != nil {
      return nil, err
     }
     return contentbytes.bytes(), nil
}

func uploadobject(bucketname string, objectname string, file *os.file) error {
    // get the stat of file
    filestat, err := file.stat()
    if err != nil {
    	return err
    }

    // upload the file
    uploadinfo, err := minioclient.putobject(
        context, 
        bucketname, 
        objectname, 
        file, 
        filestat.size(), 
        minio.putobjectoptions{})

    fmt.printf("uploaded info : %v", uploadinfo)
    return err
}

import (
    "context"
    "fmt"
    "log"

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

func setbucketlifecycle(bucketname string, days int, minioclient *minio.client) error {
    ctx := context.background()

    // 构建生命周期配置规则
    rule := lifecycle.newrule{
        id:     "rule1",
        status: "enabled",
        filter: lifecycle.newprefixfilter(""), // 这里可以指定前缀来限制规则应用到特定前缀的对象，空字符串表示应用到桶内所有对象
        expiration: lifecycle.expiration{
            days: &days, // 设置过期天数，对象创建后达到这个天数就会被自动删除
        },
    }

    // 将规则添加到生命周期配置对象中
    config := lifecycle.newconfiguration()
    config.rules = append(config.rules, rule)

    // 使用minio客户端设置存储桶的生命周期配置（即过期策略）
    err := minioclient.setbucketlifecycle(ctx, bucketname, config)
    if err!= nil {
        return fmt.errorf("设置存储桶 %s 生命周期配置失败: %v", bucketname, err)
    }

    fmt.printf("存储桶 %s 的过期策略设置成功，对象将在创建后 %d 天过期\n", bucketname, days)
    return nil
}

func main() {
    endpoint := "your_minio_endpoint"
    accesskey := "your_access_key"
    secretkey := "your_secret_key"
    bucketname := "your_bucket_name"
    days := 30 // 这里假设设置对象30天后过期，你可以按需修改

    // 创建minio客户端实例
    minioclient, err := minio.new(endpoint, &minio.options{
        credentials: minio.credentials{
            accesskey: accesskey,
            secretkey: secretkey,
        },
    })
    if err!= nil {
        log.fatalf("创建minio客户端失败: %v", err)
    }

    // 调用函数设置存储桶过期策略
    err = setbucketlifecycle(bucketname, days, minioclient)
    if err!= nil {
        log.fatalf("设置存储桶过期策略时出现错误: %v", err)
    }
}