开源对象存储系统minio部署配置与SpringBoot客户端整合访问_minio安装部署

官方介绍：
MinIO 提供高性能、与S3 兼容的对象存储系统，让你自己能够构建自己的私有云储存服务。在 GNU AGPL v3 下是 100% 开源的。

• 部署简单，只有一个minio可执行文件。
• 高性能，在 32 个 NVMe 驱动器节点和 100Gbe 网络上发布的 GET/PUT 结果超过 325 GiB/秒和 165 GiB/秒。
• Kubernetes原生支持，MinIO 支持公共云、私有云和边缘云上所有主要的 Kubernetes 发行版。

1、MinIO安装部署

1.1 下载

下载地址：https://min.io/download#/linux
linux下载：

wget https://dl.min.io/server/minio/release/linux-amd64/minio
chmod +x minio
1
2

启动命令：

minio server [FLAGS] HOSTNAME/DIRECTORIES [HOSTNAME/DIRECTORIES..]
1

服务器列表

单机启动

MINIO_ROOT_USER=admin MINIO_ROOT_PASSWORD=12345678 ./minio server --address ":9000" --console-address ":9001" /data/minio/data
1

集群启动

MINIO_ROOT_USER=admin MINIO_ROOT_PASSWORD=12345678 ./minio server \
--address ":9000" --console-address ":9001"  \
http://192.168.245.134:9000/data/minio/data  \
http://192.168.245.137:9000/data/minio/data
1
2
3
4

Minio分布式注意事项：

• 所有的节点需要有相同的access（用户名）和secret（密码）
• 存放数据的磁盘目录必须是空目录
• 官方建议生产环境最少4个节点，因为有N个节点，得至少保证有N/2的节点才能可读，保证至少N/2+1的节点才能可写。
• 节点时间必须同步，不能有大差距。
• 每个节点磁盘都存一份数据文件保证数据的可靠性与安全性

报错：

Error: Drive `/data/minio/data/data` is part of root drive, will not be used (*errors.errorString)
1

错误:驱动器’ /data/minio/data/data '是根驱动器的一部分，将不会被使用。分布式需要使用另外的挂载硬盘。
挂载硬盘方法：

# 查看未挂载的磁盘
[root@localhost]# fdisk -l

# 对新建的磁盘/dev/sdb进行分区
[root@localhost]# fdisk /dev/sdb
#输入n，#添加新的分区
#输入p，回车，#打印分区
#默认分区输入1，两次回车，
#输入w，保存分区并退出

# 格式化
[root@localhost]# mkfs -t ext4 /dev/sdb1

# 挂载硬盘
[root@localhost]# mount /dev/sdb1  /data/minio

# 设置开机自动挂载
[root@localhost]# blkid /dev/sdb1 # 查看设备UUID
[root@localhost]# vim /etc/fstab
#第一字段:分区设备文件名或UUID(硬盘通用唯一识别码，可通过“blkid /dev/sdb1”查看UUID)
#第二字段:挂载点（/data/minio）
#第三字段:文件系统名称（ext4）
#第四字段:挂载参数（defaults）
#第五字段:指定分区是否被dump备份,0代表不备份,1代表每天备份,2代表不定期备份
#第六字段:指定分区是否被fsck检测,0代表不检测,其它数字代表检测的优先级,1的优先级比2高
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

2、管理工具

MinIO提供了一套选项来涵盖数据驱动型企业中的每个角色，例如图形用户界面（GUI），命令行界面（CLI）和应用程序编程接口（API）。

2.1、图形管理工具

浏览器访问http://192.168.245.139:9001，使用上边设置的帐号密码例登录。

设置目录或文件允许直接访问：

2.2、命令管理工具

mc 是用来访问MinIO服务的命令行客户端，参考 https://min.io/docs/minio/linux/reference/minio-mc.html?ref=docs
MinIO 客户端 mc 命令行工具提供了一个类UNIX命令的替代，例如 ls, cat, cp, mirror, 以及 diff ，同时支持文件系统和亚马逊的 S3兼容云存储服务.
下载地址：https://dl.min.io/client/mc/release/linux-amd64/mc

mc alias set minio1 hhttp://192.168.245.139:9000 admin 12345678
mc alias set minio2 hhttp://192.168.245.137:9000 admin 12345678

mc alias list
mc ls minio1
1
2
3
4
5

2.3、Java SDK管理工具

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.penngo.example</groupId>
    <artifactId>minio-service</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <version>8.5.5</version>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>2022.0.0.0</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>2022.0.4</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>3.0.9</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <!-- 配置 fork 进行热部署支持  -->
                <configuration>
                    <mainClass>com.penngo.example.MinioApp</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>
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
66
67
68
69
70
71
72

application.yml

server:
  port: 8080
  servlet:
    encoding:
      force: true
      charset: UTF-8
      enabled: true
minio:
  access-key: admin
  secret-key: 12345678
  url: http://192.168.245.139:9000
1
2
3
4
5
6
7
8
9
10
11

MinioConfig.java

package com.penngo.example.component;

import io.minio.MinioClient;
import io.minio.messages.Bucket;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.List;

@Configuration
@ConfigurationProperties(prefix = "minio")
public class MinioConfig {
    /**
     * 用户名
     */
    private String accessKey;
    /**
     * 密码
     */
    private String secretKey;
    /**
     * Minio 服务端 api地址
     */
    private String url;

    public void setAccessKey(String accessKey) {
        this.accessKey = accessKey;
    }

    public void setSecretKey(String secretKey) {
        this.secretKey = secretKey;
    }

    public void setUrl(String url) {
        this.url = url;
    }


    public String getAccessKey() {
        return accessKey;
    }

    public String getSecretKey() {
        return secretKey;
    }

    public String getUrl() {
        return url;
    }


    /**
     * 构建 操作Minio的客户端
     * @return
     */
    @Bean("minioClient")
    public MinioClient minioClient() {
        System.out.println(url + "," + accessKey + "," + secretKey);
        MinioClient minioClient = MinioClient.builder()
                .endpoint(url)
                .credentials(accessKey, secretKey)
                .build();
        try{
            List<Bucket> list = minioClient.listBuckets();
            System.out.println("Bucket List:" + list.size());
        }
        catch(Exception e){
            e.printStackTrace();
        }
        return minioClient;
    }
}
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
66
67
68
69
70
71
72

MinioUtils.java

package com.penngo.example.component;

import io.minio.*;
import io.minio.http.Method;
import io.minio.messages.Item;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Component;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

@Component
public class MinioUtils {
    private String bucketName = "test-bucket";
    @Resource
    private MinioClient minioClient;

    /**
     * 创建桶
     */
    public boolean createBucket(){
        try{
            boolean found = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
            if (!found) {
                minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
            }
            return true;
        }
        catch(Exception e){
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 删除桶
     */
    public void removeBucket(String bucketName) throws Exception{
        minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
    }

    /**
     * 上传文件
     */
    public boolean uploadFile(String fileName, InputStream stream, Long fileSize, String type){
        try{
            minioClient.putObject(PutObjectArgs.builder().bucket(bucketName).object(fileName).stream(stream, fileSize, -1)
                    .contentType(type).build());
            return true;
        }
        catch(Exception e){
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 判断文件夹是否存在
     * @return
     */
    public Boolean folderExists(String bucketName, String prefix) throws Exception{
        Iterable<Result<Item>> results = minioClient.listObjects(ListObjectsArgs.builder().bucket(bucketName).prefix(
                prefix).recursive(false).build());
        for (Result<Item> result : results) {
            Item item = result.get();
            if (item.isDir()) {
                return true;
            }
        }
        return false;
    }

    /**
     * 创建文件夹
     *
     * @param bucketName 桶名称
     * @param path 路径
     */
    public void createFolder(String bucketName, String path) throws Exception{
        minioClient.putObject(PutObjectArgs.builder().bucket(bucketName).object(path)
                .stream(new ByteArrayInputStream(new byte[] {}), 0, -1).build());
    }

    /**
     * 获取文件在minio在服务器上的外链
     *
     */
    public String getUrl(String objectName) throws Exception{
        return minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder().method(Method.GET).bucket(
                bucketName).object(objectName).expiry(1, TimeUnit.DAYS).build());
    }

    /**
     * 获取minio中,某个bucket中所有的文件名
     */
    public Map<String, String> getFileList() {
        Iterable<Result<Item>> results = minioClient.listObjects(ListObjectsArgs.builder().bucket(bucketName)
                .recursive(true).build());
        Map<String, String> fileUrlData = new HashMap<>();
        for (Result<Item> result : results) {
            Item item;
            String fileName = null;
            try {
                item = result.get();
                fileName = item.objectName();
                String url = getUrl(fileName);
                fileUrlData.put(fileName, url);
            } catch (Exception e) {
               e.printStackTrace();
            }
        }
        return fileUrlData;
    }
}
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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

FileController.java

package com.penngo.example.controlleer;

import com.penngo.example.component.MinioUtils;
import jakarta.annotation.Resource;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.io.File;
import java.io.FileInputStream;
import java.util.Map;

@RestController
public class FileController {

    @Resource
    private MinioUtils minioUtils;

    @GetMapping("/hello")
    public String hello(){
        return "FileController:Hello";
    }
    /**
     * 创建桶
     */
    @GetMapping("/createBucket")
    public String createBucket() throws Exception{
        boolean b = minioUtils.createBucket();
        return "createBucket:" + b;
    }

    /**
     * 上传文件
     */
    @GetMapping("/uploadFile")
    public String uploadFile(){
        String filePath = "D:\\project\\测试.docx";
        File file = new File(filePath);
        boolean b = false;
        try {
            FileInputStream fileInputStream = new FileInputStream(file);
            b = minioUtils.uploadFile(file.getName(), fileInputStream, file.length(), "application/vnd.openxmlformats-officedocument.wordprocessingml.document");
        }
        catch(Exception e){
            e.printStackTrace();
        }
        return "uploadFile:" + b;
    }
    @GetMapping("/fileList")
    public String fileList(){
        Map<String, String> files =  minioUtils.getFileList();
        StringBuffer sff = new StringBuffer();
        files.forEach((k,v)->{
            sff.append(k).append(":<a target='blank' href=").append(v).append(">").append(v).append("</a><br/>");
        });
        return sff.toString();
    }
}
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

MinioApp.java

package com.penngo.example;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MinioApp {
    public static void main(String[] args) {
        SpringApplication.run(MinioApp.class, args);
    }
}
1
2
3
4
5
6
7
8
9
10

运行效果：


更多官方java例子:https://github.com/minio/minio-java/tree/release/examples

3、MinIO Server配置参数

3.1、启动参数：

• HOSTNAME
  minio服务器进程的主机名。

https://minio1.example.net
https://minio2.example.net
1
2

• DIRECTORIES
  必须，minio存储的目录。

/mnt/data1
/mnt/data2
1
2

• –address
  可选，将minio绑定到特定的网络地址和端口号。将地址和端口指定为address: port，

#/etc/hosts
127.0.1.1       minioip
127.0.1.2       minioip

#启动
minio server --address "minioip:9000" ~/miniodirectory
1
2
3
4
5
6

• –console-address
  可选，minio管理控制台的静态端口。

• –ftp
  可选，启用并配置FTP (File Transfer Protocol)或FTPS (File Transfer Protocol over SSL/TLS)服务器。

minio server http://server{1...4}/disk{1...4} \
--ftp="address=:8021"                         \
--ftp="passive-port-range=30000-40000"        \
--ftp="tls-private-key=path/to/private.key"   \
--ftp="tls-public-cert=path/to/public.crt"    \
...
1
2
3
4
5
6

• –sftp
  可选，启用并配置SFTP服务器。

minio server http://server{1...4}/disk{1...4}                               \
--sftp="address=:8022" --sftp="ssh-private-key=/home/miniouser/.ssh/id_rsa" \
...
1
2
3

• –certs-dir, -S
  可选，minio进程用于配置TLS/SSL连接的证书所在文件夹的路径。

• –quiet
  可选，禁用启动信息。

• –anonymous
  可选，在日志记录中隐藏敏感信息。

• –json
  可选，以JSON格式输出服务器日志和启动信息。

3.2、环境变量

• MINIO_VOLUMES
  minio服务器进程用作存储后端的目录或驱动器。
  功能上等同于设置minio服务器目录。在配置MinIO使用环境文件运行时使用此值。

# MinIO configuration file
MINIO_VOLUMES="/data/minio" #配置存储目录
MINIO_OPTS="-C /etc/minio --address :9000" #配置minio监听端口
MINIO_ROOT_USER="minioadmin" #配置用户名
MINIO_ROOT_PASSWORD="minioadmin" #配置密码
#MINIO_OPTS="--address 0.0.0.0:9000 --console-address '0.0.0.0:9001'"  #指定控制台端口，不指定则默认和minio一致
1
2
3
4
5
6

MINIO_CONFIG_ENV_FILE
指定MinIO服务器进程用于加载环境变量的文件的完整路径。

docker run -dt \
--name "minio_local" \
--net=host \
-v /momo/app/minio/data:/mnt/data \
-v /momo/app/minio/config/config.env:/etc/config.env \
-e "MINIO_CONFIG_ENV_FILE=/etc/config.env" \
bitnami/minio:2022.9.17 \
minio server --console-address ":9990"
1
2
3
4
5
6
7
8

MINIO_ILM_EXPIRY_WORKERS
使用ILM过期规则检查过期对象的工作线程数。如果没有设置，MinIO默认使用最多一半的可用内核。

MINIO_DOMAIN
配置minio支持基于域名的访问模式

export MINIO_DOMAIN=minio.domain
1

MINIO_SCANNER_SPEED
在平衡MinIO读/写性能到扫描器进程时，管理扫描器的最大等待时间。

3.3、Root验证参数

MINIO_ROOT_USER
root用户的访问键。

MINIO_ROOT_PASSWORD
root用户的密钥。

MINIO_API_ROOT_ACCESS
Minio API root访问权限

MINIO_API_ROOT_ACCESS
指定on为启用，off为禁用根用户帐户。禁用root服务帐户也会禁用与root关联的所有服务帐户，但不包括用于站点复制的服务帐户。默认为开启。

配置参考：https://min.io/docs/minio/linux/reference/minio-server/minio-server.html#command-minio.server

4、MinIO Client可用命令

mc可以命令

官方参考：https://min.io/docs/minio/linux/reference/minio-mc.html