开发侧文档
边缘计算平台
边缘服务

minion

# minion服务

# 1、功能介绍：

文件对象管理，基于minion的对象管理服务，全兼容s3的对象管理接口

开发者接入方式：

9000为对外提供的web页面

# 2、开发者接入方式：

# 2.1、常用命令：

常用命令：

admin登录：
mc alias set minio http://10.2.92.12:9000 minioadmin minioadmin

添加用户：
mc admin user add myminio user1 user1123 --insecure=true

添加策略：
mc admin policy add myminio getonly getonly.json --insecure=true

列出策略：
mc admin policy list myminio/h1 --insecure=true

给用户分配策略：
mc admin policy set myminio getonly user=user1 --insecure=true

查看用户策略：
mc admin user info myminio user1 --insecure=true

删除策略：
mc admin policy remove myminio/h1 getonly --insecure=true

查看服务日志：

mc admin trace -a --insecure --debug myminio

#查看minio bucket
mc ls minio

#创建bucket
mc mb minio/backup

#上传本地目录(文件不加r)
mc cp -r ingress minio/backup/

#下载远程目录(文件不加r)
mc cp -r minio/backup .

#将一个本地文件夹镜像到minio(类似rsync)
mc mirror localdir/ minio/backup/

#持续监听本地文件夹镜像到minio(类似rsync)
mc mirror -w localdir/ minio/backup/

#持续从minio存储桶中查找所有jpeg图像，并复制到minio "play/bucket"存储桶
mc find minio/bucket --name "*.jpg" --watch --exec "mc cp {} play/bucket"

#删除目录
mc rm minio/backup/ingress --recursive --force

#删除文件
mc rm minio/backup/service_minio.yaml

#从mybucket里删除所有未完整上传的对象
mc rm --incomplete --recursive --force play/mybucket

#删除7天前的对象
mc rm --force --older-than=7 play/mybucket/oldsongs

#将MySQL数据库dump文件输出到minio
mysqldump -u root -p ******* db | mc pipe minio/backups/backup.sql

#mongodb备份
mongodump -h mongo-server1 -p 27017 -d blog-data --archive | mc pipe minio1/mongobkp/backups/mongo-blog-data-`date +%Y-%m-%d`.archive

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

# 2.2、api

所有代码片段都是基于golang，其他语言请参考官方文档：

https://docs.min.io/docs/ （MINIO SDKS (opens new window)）

# 2.2.1、创建存储桶 MakeBucket:

func makeBucket(ctx context.Context, bucketName string) {
   var (
      err error
   )
 
   err = minioClient.MakeBucket(ctx, bucketName, minio.MakeBucketOptions{Region: location})
   if err != nil {
      // Check to see if we already own this bucket (which happens if 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("Succcessfully created %s\n", bucketName)
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 2.2.2、列出存储桶 ListBucket

func listBucket(ctx context.Context) {
    buckets, err := minioClient.ListBuckets(ctx)
    if err != nil {
        log.Fatalln(err)
    }
    for _, bucket := range buckets {
        log.Println(bucket)
    }
}

1
2
3
4
5
6
7
8
9

# 2.2.3、删除存储桶 RemoveBucket

err = minioClient.RemoveBucket(context.Background(), "mybucket")
if err != nil {
   fmt.Println(err)
}

1
2
3
4

# 2.2.4、列出对象 ListObjects

func listObjects(ctx context.Context, bucketName string)  {
   opts := minio.ListObjectsOptions{
      UseV1: true,
      Prefix: "",
      Recursive: true,
   }

   for object := range minioClient.ListObjects(ctx, bucketName, opts) {
      if object.Err != nil {
         log.Fatalln(object.Err)
         return
      }
      o, _ := json.Marshal(object)
      log.Println(string(o))
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 2.2.5、上传对象 PutObject

将文件上传到指定bucket，如果想在bucket中新建目录，上传到指定目录，见下面代码注释：

func putObject(ctx context.Context, filePath, objectName, bucketName string)  {
   object, err := os.Open(filePath)
   if err != nil {
      log.Fatalln(err)
   }
   defer object.Close()
   objectStat, err := object.Stat()
   if err != nil {
      log.Fatalln(err)
   }
   n, err := minioClient.PutObject(ctx, bucketName, "123/" + objectName, object, objectStat.Size(),  // 此处在指定bucket中创建一个文件夹123，并将文件保存到此
      minio.PutObjectOptions{ContentType: "application/octet-stream"})
   if err != nil {
      log.Fatalln(err)
   }
   log.Println("Uploaded", objectName, "of size:", n, " Successfully.")

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 2.2.6、获取对象内容 GetObject

获取对象内容保存成文件：

func getObject(ctx  context.Context, bucketName, objectName string)  {
   reader, err := minioClient.GetObject(ctx, bucketName, objectName, minio.GetObjectOptions{})
   if err != nil {
      log.Fatalln(err)
   }
   defer reader.Close()

   localFile, err := os.Create(objectName+".down")
   defer localFile.Close()
   if err != nil {
      log.Fatalln(err)
   }
   stat, err := reader.Stat()
   if err != nil {
      log.Fatalln(err)
   }
   if _, err := io.CopyN(localFile, reader, stat.Size); err != nil {
      log.Fatalln(err)
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 2.2.7、删除对象 RemoveObject

func removeObject(ctx context.Context, bucketName, objectName string)  {
   opts := minio.RemoveObjectOptions{
      GovernanceBypass: true,
   }

   if err := minioClient.RemoveObject(ctx, bucketName, objectName, opts); err != nil {
      log.Fatalln(err)
   }
   log.Println("remove object successful.")
}

1
2
3
4
5
6
7
8
9
10

上次更新: 2021-12-01 16:48:01

← data nats→