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 := javascript"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(""), // 这里可以指定前缀来限制规则应用http://www.chinasem.cn到特定前缀的对象，空字符串表示应用到桶内所有对象
        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)
    }
}