CentOS下安装Minio、搭建Minio集群、SpringBoot整合Minio

CentOS下安装Minio、搭建Minio集群、SpringBoot整合Minio

Minio是目前github上赞最多的开源OSS（Object Storage Service），支持分布式部署。

1、搭建服务端(单点)

1.1、下载

Minio的安装包非常简单，只有一个可执行文件，下面是下载地址：

wget https://dl.min.io/server/minio/release/linux-amd64/minio

1.2、授权

在linux环境下载好后，需要对可执行文件授权，否则默认无执行权限

chmod +x minio

1.3、启动服务端

• 启动脚本前需加上MINIO_ROOT_USER=xxx初始化默认的账号
• 启动脚本前需加上MINIO_ROOT_PASSWORD=xxx初始化默认的密码
• nohup：后台启动，切断开ssh后不关闭
• ./minio server /home/minio/data启动服务端，将文件存储至/home/minio/data，文件存储目录不能是根目录/的挂载点，也不能是/root的挂载点
• --console-address ":9001"，初始化默认的端口和ip
• >/opt/minio/minio.log 2>&1 &，初始化日志记录位置

MINIO_ROOT_USER=admin MINIO_ROOT_PASSWORD=password nohup ./minio server /home/minio/data --console-address ":9001" >/opt/minio/minio.log 2>&1 &

1.4、注册服务，设置开机自启

vim /usr/lib/systemd/system/minio.service

编写服务脚本，其中环境变量为默认账号密码，

[Unit]
Description=Minio Service

[Service]
Environment="MINIO_ROOT_USER=admin"
Environment="MINIO_ROOT_PASSWORD=password"
ExecStart=/opt/minio/minio server /home/minio/data --console-address ":9001"
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/bin/kill -s QUIT $MAINPID
StandardOutput=/opt/minio/minio.log
PrivateTmp=true

[Install]
WantedBy=multi-user.target

查找mino进程，先关闭minio

[root@dev minio]# ps -ef|grep minio
root      4298  1592  2 14:08 pts/0    00:00:03 ./minio server /home/minio/data --console-address :9001
root      4759  1592  0 14:10 pts/0    00:00:00 grep --color=auto minio

[root@dev minio]# kill -9 4298

启动服务，设置开机自启

# 重新刷新
systemctl daemon-reload
# 启动
systemctl start minio.service
# 查看状态
systemctl status minio -l
# 开机自启
systemctl enable minio.service

其他命令：

# 启动minio
systemctl start minio
 
#设置开机自启动
systemctl enable minio 
 
#停止开机自启动
systemctl disable minio
 
#查看服务当前状态 
systemctl status minio
 
#重新启动服务
systemctl restart minio　  
 
#查看所有已启动的服务 
systemctl list-units --type=service 

1.5、开放端口号

# 开放9000端口
firewall-cmd --zone=public --add-port=9000/tcp --permanent
# 开放9001端口
firewall-cmd --zone=public --add-port=9001/tcp --permanent
# 立即生效
firewall-cmd --reload

1.6、验证

在通网络段内，使用有界面的OS，打开任意浏览器，输入服务器ip:9001,例如：http://192.168.90.134:9001，输入环境变量中的账号密码即可登录。

2、搭建客户端

客户端可以通过命令的形式设置minio的一些参数，例如minio的默认分享链接只有七天，对于一些开发场景不太友好，可以通过客户端的形式将其改为永久。

2.1、下载

wget https://dl.min.io/client/mc/release/linux-amd64/mc

2.2、授权

chmod +x mc

2.3、设置桶的读写权限

将服务端添加到客户端配置管理

# 使用 minio client 将我自己的 minio server 添加到 mc 的配置管理。
./mc config host add minio http://192.168.90.133:9000 admin password --api S3v4

永久访问其实就是开放权限... 只需要在对应的桶上设置读写权限就可以了 可以在浏览器上直接操作

# 配置下载策略（设置分享永久有效）
./mc policy set public minio/mybucket(这个是你自己的桶名字)

3、集群搭建

Minio官方推荐的最小集群环境为四台服务器，本文使用四台服务器演示搭建。注意：集群的搭建和单点的方式不一致，搭建集群时，请确保未安装minio

• 确保数据存储目录是一个空的挂载卷，不能是跟目录或root目录的挂载点
• 确保四台服务器的时间同步
• 需开启9001、9000端口的防火墙

3.1、机器资源

# 机器1
192.168.90.134

# 机器2
192.168.90.135

# 机器3
192.168.90.136

# 机器4
192.168.90.137

以下操作需要分别在这四台服务器执行

3.2、集群配置

首先分别在四台机器的/opt/minio目录，下载minio

# 进入安装目录
cd /opt/minio

# 下载部署包
wget https://dl.min.io/server/minio/release/linux-amd64/minio

# 授权
chmod +x minio

然后编辑如下脚本：

mkdir -p /var/minio/bin
vim /var/minio/bin/run.sh

内容：

#!/bin/bash
export MINIO_ACCESS_KEY=admin
export MINIO_SECRET_KEY=password

/opt/minio/minio server --config-dir /etc/minio  --address ":9000" --console-address ":9001" \
http://192.168.90.134/home/minio/data http://192.168.90.135/home/minio/data \
http://192.168.90.136/home/minio/data http://192.168.90.137/home/minio/data

• /home/minio/data建议使用一个单独的挂载卷，且此卷下不要放任何文件，挂载自动生成的lost+found可忽略。
• *注意里面的#!/bin/bash，不加的话后续使用服务启动会直接结束，会出现main process exited, code=exited, status=203/EXEC

其中：

• “MINIO_ACCESS_KEY”为用户名
• “MINIO_SECRET_KEY”为密码，密码不能设置过于简单，不然minio会启动失败
• “-config-dir”指定集群配置文件目录

授权：

chmod +x /var/minio/bin/run.sh

3.3、注册开机自启

3.3.1、编写启动脚本

创建服务文件：

vim /usr/lib/systemd/system/minio.service

内容：

[Unit]
Description=Minio service
Documentation=https://docs.minio.io/

[Service]
WorkingDirectory=/opt/minio/
ExecStart=/var/minio/bin/run.sh

Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target

其中：

• “WorkingDirectory”为minio服务目录
• “ExecStart”为指定集群启动脚本

3.3.2、开放端口：

# 开放9000端口
firewall-cmd --zone=public --add-port=9000/tcp --permanent
# 开放9001端口
firewall-cmd --zone=public --add-port=9001/tcp --permanent
# 立即生效
firewall-cmd --reload

3.3.3、启动服务，设置开机自启

注意：以下命令需以此在每台服务器执行，最少4块磁盘才能顺利启动，得保证4台机器都处于启动状态，并通信正常。（并非启动好一台再下一台）。

# 重新刷新
systemctl daemon-reload
# 启动
systemctl start minio.service
# 查看状态
systemctl status minio -l
# 开机自启
systemctl enable minio.service

• 如果启动报错，确认是否开放防火墙的9001、9000端口，若仍然启动不成功，可采用/data/minio/run/run.sh直接启动，查看输出内容。
• 如果启动失败可以手动执行/var/minio/bin/run.sh查看日志。

其他命令：

# 启动minio
systemctl start minio
 
#设置开机自启动
systemctl enable minio 
 
#停止开机自启动
systemctl disable minio
 
#查看服务当前状态 
systemctl status minio
 
#重新启动服务
systemctl restart minio　  
 
#查看所有已启动的服务 
systemctl list-units --type=service 

3.4、配置桶永久下载地址

安装minio客户端：

# 下载
wget https://dl.min.io/client/mc/release/linux-amd64/mc

# 授权
chmod +x mc

配置服务端host，分别执行：

./mc config host add minio-134 http://192.168.90.134:9000/ admin password S3v4
./mc config host add minio-135 http://192.168.90.135:9000/ admin password S3v4
./mc config host add minio-136 http://192.168.90.136:9000/ admin password S3v4
./mc config host add minio-137 http://192.168.90.137:9000/ admin password S3v4

配置桶策略，设置永久有效，分别执行：

./mc policy set download minio-134 /data
./mc policy set download minio-135 /data
./mc policy set download minio-136 /data
./mc policy set download minio-137 /data

这个命令的作用是将 server 端的 data 桶设置为开放管理，可以直接通过 url (nginx或任意节点)进行下载。

[桶名]/[路径]可以一直拼接到具体的文件夹或文件

类似于以下 http://xxx.xxx.xxx.xxx:9000/dev/xxx.zip，可用浏览器直接从此URL访问下载。

3.5、验证

四台机器全部正常启动，在浏览器输入http://192.168.90.xx:9001(任意一台的IP)即可访问。

4、配置Nginx

配置nginx 支持lb（支持集群节点；支持多集群混用）
upstream minio-server {
  server 192.168.90.134:9000 weight=25 max_fails=2 fail_timeout=30s;
  server 192.168.90.135:9000 weight=25 max_fails=2 fail_timeout=30s;
  server 192.168.90.136:9000 weight=25 max_fails=2 fail_timeout=30s;
  server 192.168.90.137:9000 weight=25 max_fails=2 fail_timeout=30s;
}
server {
  listen 80;
  server_name localhost;
  charset utf-8;
  default_type text/html;
  location /{
    proxy_set_header Host $http_host;
    proxy_set_header X-Forwarded-For $remote_addr;
    client_body_buffer_size 10M;
    client_max_body_size 10G;
    proxy_buffers 1024 4k;
    proxy_read_timeout 300;
    proxy_next_upstream error timeout http_404;
    proxy_pass http://minio-server;
  }
}

5、SpringBoot集成Minio

pom

<?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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.10</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>cn.vantee</groupId>
    <artifactId>minIO</artifactId>
    <version>1.0.0</version>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <version>8.3.3</version>
        </dependency>

        <dependency>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>okhttp</artifactId>
            <version>4.9.0</version>
            <exclusions>
                <exclusion>
                    <groupId>org.jetbrains.kotlin</groupId>
                    <artifactId>kotlin-stdlib</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-stdlib</artifactId>
            <version>1.5.32</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

配置文件：application.properties

#minio.endpoint=http://192.168.90.133:9000
minio.endpoint=192.168.90.133:9000
minio.bucketName=hnpy
minio.accessKey=c478406a24b9433c864e4f0282d1f4ae
minio.secretKey=0af6be857cbd4dd3b2ba6b7fc1f8c093
minio.imgSize=10485760
minio.fileSize=10485760
minio.separator=/

配置类：

package cn.vantee.common.util;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * @author ：rayfoo@qq.com
 * @date ：Created in 2022/3/18 4:58 下午
 * @description：minio配置
 * @modified By：
 * @version: 1.0.0
 */
@Component
@Data
@ConfigurationProperties(prefix = "minio")
public class MinioProperties {

    /**
     * 连接地址
     */
    private String endpoint;

    /**
     * 桶名称
     */
    private String bucketName;

    /**
     * 账号
     */
    private String accessKey;

    /**
     * 密码
     */
    private String secretKey;

    /**
     * 图片大小
     */
    private Integer imgSize;

    /**
     * 文件大小
     */
    private Integer fileSize;

    /**
     * 分隔符
     */
    private String separator;

}

工具类：

package cn.vantee.common.util;

import io.minio.*;
import io.minio.http.Method;
import io.minio.messages.Bucket;
import io.minio.messages.DeleteObject;
import io.minio.messages.Item;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.PostConstruct;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Optional;

/**
 * @author ：rayfoo@qq.com
 * @date ：Created in 2022/3/21 10:03 上午
 * @description：minio工具类
 * @modified By：
 * @version:
 */
@Slf4j
@Component
public class MinIoUtil {

    @Autowired
    MinioProperties minioProperties;

    private MinioClient minioClient;

    /**
     * 初始化minio配置
     */
    @PostConstruct
    public void init(){
        try{
            if (null == minioClient) {
                log.info("开始创建 MinioClient...");
                minioClient = MinioClient
                        .builder()
                        .endpoint(minioProperties.getEndpoint())
                        .credentials(minioProperties.getAccessKey(), minioProperties.getSecretKey())
                        .build();
                createBucket(minioProperties.getBucketName());
                log.info("创建完毕 MinioClient...");
            }
        } catch (Exception e) {
            log.error("[Minio工具类]>>>> MinIO服务器异常：", e);
        }
    }

    /**
     * 获取上传文件前缀路径
     * @return
     */
    public String getBasisUrl() {
        return minioProperties.getEndpoint() + minioProperties.getSeparator() + minioProperties.getBucketName() + minioProperties.getSeparator();
    }

    /******************************  Operate Bucket Start  ******************************/

    /**
     * 启动SpringBoot容器的时候初始化Bucket
     * 如果没有Bucket则创建
     * @throws Exception
     */
    private void createBucket(String bucketName) throws Exception {
        if (!bucketExists(bucketName)) {
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
            //修改桶策略为读写权限
            String READ_WRITE = "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]},\"Action\":[\"s3:GetBucketLocation\",\"s3:ListBucket\",\"s3:ListBucketMultipartUploads\"],\"Resource\":[\"arn:aws:s3:::" + bucketName + "\"]},{\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]},\"Action\":[\"s3:DeleteObject\",\"s3:GetObject\",\"s3:ListMultipartUploadParts\",\"s3:PutObject\",\"s3:AbortMultipartUpload\"],\"Resource\":[\"arn:aws:s3:::" + bucketName + "/*\"]}]}";
            minioClient.setBucketPolicy(SetBucketPolicyArgs.builder().bucket(bucketName).config(READ_WRITE).build());
        }
    }

    /**
     *  判断Bucket是否存在，true：存在，false：不存在
     * @return
     * @throws Exception
     */
    public boolean bucketExists(String bucketName) throws Exception {
        return minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
    }


    /**
     * 获得Bucket的策略
     * @param bucketName
     * @return
     * @throws Exception
     */
    public String getBucketPolicy(String bucketName) throws Exception {
        return minioClient
                .getBucketPolicy(
                        GetBucketPolicyArgs
                                .builder()
                                .bucket(bucketName)
                                .build()
                );
    }


    /**
     * 获得所有Bucket列表
     * @return
     * @throws Exception
     */
    public List<Bucket> getAllBuckets() throws Exception {
        return minioClient.listBuckets();
    }

    /**
     * 根据bucketName获取其相关信息
     * @param bucketName
     * @return
     * @throws Exception
     */
    public Optional<Bucket> getBucket(String bucketName) throws Exception {
        return getAllBuckets().stream().filter(b -> b.name().equals(bucketName)).findFirst();
    }

    /**
     * 根据bucketName删除Bucket，true：删除成功； false：删除失败，文件或已不存在
     * @param bucketName
     * @throws Exception
     */
    public void removeBucket(String bucketName) throws Exception {
        minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
    }

    /******************************  Operate Bucket End  ******************************/


    /******************************  Operate Files Start  ******************************/

    /**
     * 判断文件是否存在
     * @param bucketName 存储桶
     * @param objectName 文件名
     * @return
     */
    public boolean isObjectExist(String bucketName, String objectName) {
        boolean exist = true;
        try {
            minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build());
        } catch (Exception e) {
            log.error("[Minio工具类]>>>> 判断文件是否存在, 异常：", e);
            exist = false;
        }
        return exist;
    }

    /**
     * 判断文件夹是否存在
     * @param bucketName 存储桶
     * @param objectName 文件夹名称
     * @return
     */
    public boolean isFolderExist(String bucketName, String objectName) {
        boolean exist = false;
        try {
            Iterable<Result<Item>> results = minioClient.listObjects(
                    ListObjectsArgs.builder().bucket(bucketName).prefix(objectName).recursive(false).build());
            for (Result<Item> result : results) {
                Item item = result.get();
                if (item.isDir() && objectName.equals(item.objectName())) {
                    exist = true;
                }
            }
        } catch (Exception e) {
            log.error("[Minio工具类]>>>> 判断文件夹是否存在，异常：", e);
            exist = false;
        }
        return exist;
    }

    /**
     * 根据文件前置查询文件
     * @param bucketName 存储桶
     * @param prefix 前缀
     * @param recursive 是否使用递归查询
     * @return MinioItem 列表
     * @throws Exception
     */
    public List<Item> getAllObjectsByPrefix(String bucketName,
                                                   String prefix,
                                                   boolean recursive) throws Exception {
        List<Item> list = new ArrayList<>();
        Iterable<Result<Item>> objectsIterator = minioClient.listObjects(
                ListObjectsArgs.builder().bucket(bucketName).prefix(prefix).recursive(recursive).build());
        if (objectsIterator != null) {
            for (Result<Item> o : objectsIterator) {
                Item item = o.get();
                list.add(item);
            }
        }
        return list;
    }

    /**
     * 获取文件流
     * @param bucketName 存储桶
     * @param objectName 文件名
     * @return 二进制流
     */
    public InputStream getObject(String bucketName, String objectName) throws Exception {
        return minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(objectName).build());
    }

    /**
     * 断点下载
     * @param bucketName 存储桶
     * @param objectName 文件名称
     * @param offset 起始字节的位置
     * @param length 要读取的长度
     * @return 二进制流
     */
    public InputStream getObject(String bucketName, String objectName, long offset, long length)throws Exception {
        return minioClient.getObject(
                GetObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .offset(offset)
                        .length(length)
                        .build());
    }

    /**
     * 获取路径下文件列表
     * @param bucketName 存储桶
     * @param prefix 文件名称
     * @param recursive 是否递归查找，false：模拟文件夹结构查找
     * @return 二进制流
     */
    public Iterable<Result<Item>> listObjects(String bucketName, String prefix,
                                                     boolean recursive) {
        return minioClient.listObjects(
                ListObjectsArgs.builder()
                        .bucket(bucketName)
                        .prefix(prefix)
                        .recursive(recursive)
                        .build());
    }

    /**
     * 使用MultipartFile进行文件上传
     * @param bucketName 存储桶
     * @param file 文件名
     * @param objectName 对象名
     * @param contentType 类型
     * @return
     * @throws Exception
     */
    public ObjectWriteResponse uploadFile(String bucketName, MultipartFile file,
                                                 String objectName, String contentType) throws Exception {
        InputStream inputStream = file.getInputStream();
        return minioClient.putObject(
                PutObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .contentType(contentType)
                        .stream(inputStream, inputStream.available(), -1)
                        .build());
    }

    /**
     * 上传本地文件
     * @param bucketName 存储桶
     * @param objectName 对象名称（落盘名称 需要加后缀 如：xx.jpg）
     * @param fileName 本地文件路径
     */
    public ObjectWriteResponse uploadFile(String bucketName, String objectName,
                                                 String fileName) throws Exception {
        return minioClient.uploadObject(
                UploadObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .filename(fileName)
                        .build());
    }

    /**
     * 通过流上传文件
     *
     * @param bucketName 存储桶
     * @param objectName 文件对象
     * @param inputStream 文件流
     */
    public ObjectWriteResponse uploadFile(String bucketName, String objectName, InputStream inputStream) throws Exception {
        return minioClient.putObject(
                PutObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .stream(inputStream, inputStream.available(), -1)
                        .build());
    }

    /**
     * 创建文件夹或目录
     * @param bucketName 存储桶
     * @param objectName 目录路径
     */
    public ObjectWriteResponse createDir(String bucketName, String objectName) throws Exception {
        return minioClient.putObject(
                PutObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .stream(new ByteArrayInputStream(new byte[]{}), 0, -1)
                        .build());
    }

    /**
     * 获取文件信息, 如果抛出异常则说明文件不存在
     *
     * @param bucketName 存储桶
     * @param objectName 文件名称
     */
    public String getFileStatusInfo(String bucketName, String objectName) throws Exception {
        return minioClient.statObject(
                StatObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .build()).toString();
    }

    /**
     * 拷贝文件
     *
     * @param bucketName 存储桶
     * @param objectName 文件名
     * @param srcBucketName 目标存储桶
     * @param srcObjectName 目标文件名
     */
    public ObjectWriteResponse copyFile(String bucketName, String objectName,
                                               String srcBucketName, String srcObjectName) throws Exception {
        return minioClient.copyObject(
                CopyObjectArgs.builder()
                        .source(CopySource.builder().bucket(bucketName).object(objectName).build())
                        .bucket(srcBucketName)
                        .object(srcObjectName)
                        .build());
    }

    /**
     * 删除文件
     * @param bucketName 存储桶
     * @param objectName 文件名称
     */
    public void removeFile(String bucketName, String objectName) throws Exception {
        minioClient.removeObject(
                RemoveObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .build());
    }

    /**
     * 批量删除文件
     * @param bucketName 存储桶
     * @param keys 需要删除的文件列表
     * @return
     */
    public void removeFiles(String bucketName, List<String> keys) {
        List<DeleteObject> objects = new LinkedList<>();
        keys.forEach(s -> {
            objects.add(new DeleteObject(s));
            try {
                removeFile(bucketName, s);
            } catch (Exception e) {
                log.error("[Minio工具类]>>>> 批量删除文件，异常：", e);
            }
        });
    }

    /**
     * 获取文件外链
     * @param bucketName 存储桶
     * @param objectName 文件名
     * @param expires 过期时间 <=7 秒 （外链有效时间（单位：秒））
     * @return url
     * @throws Exception
     */
    public String getPresignedObjectUrl(String bucketName, String objectName, Integer expires) throws Exception {
        GetPresignedObjectUrlArgs args = GetPresignedObjectUrlArgs.builder().expiry(expires).bucket(bucketName).object(objectName).build();
        return minioClient.getPresignedObjectUrl(args);
    }

    /**
     * 获得文件外链
     * @param bucketName
     * @param objectName
     * @return url
     * @throws Exception
     */
    public String getPresignedObjectUrl(String bucketName, String objectName) throws Exception {
        GetPresignedObjectUrlArgs args = GetPresignedObjectUrlArgs.builder()
                .bucket(bucketName)
                .object(objectName)
                .method(Method.GET).build();
        return minioClient.getPresignedObjectUrl(args);
    }

    /**
     * 将URLDecoder编码转成UTF8
     * @param str
     * @return
     * @throws UnsupportedEncodingException
     */
    public String getUtf8ByURLDecoder(String str) throws UnsupportedEncodingException {
        String url = str.replaceAll("%(?![0-9a-fA-F]{2})", "%25");
        return URLDecoder.decode(url, "UTF-8");
    }

    /******************************  Operate Files End  ******************************/

}

文件上传：

package cn.vantee.rest.controller;

import cn.vantee.common.util.MinIoUtil;
import cn.vantee.common.util.MinioProperties;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

/**
 * @author ：rayfoo@qq.com
 * @date ：Created in 2022/3/18 5:42 下午
 * @description：文件上传下载
 * @modified By：
 * @version:
 */
@RestController
@Slf4j
public class MinioController {

    @Autowired
    MinioProperties minioProperties;

    @Autowired
    MinIoUtil minioUtil;

    /**
     * 文件上传demo，返回url
     * @param multipartFile
     * @return
     */
    @PostMapping("/upload")
    @SneakyThrows
    public String uploadFile(@RequestParam("file") MultipartFile multipartFile){
        // 获取文件名
        String fileName = multipartFile.getOriginalFilename();
        // 上传文件
        minioUtil.uploadFile(minioProperties.getBucketName(),multipartFile,fileName,"multipart/form-data;");
        // 获取文件url
        String url = minioUtil.getBasisUrl() + fileName;
        // 打印日志
        log.info("文件上传成功：" + url);
        return url;
    }

}

参考：[CentOS-搭建MinIO集群](https://www.cnblogs.com/zyrs/p/13653142.html)

参考：minio单机、集群搭建、Spring Boot集成，详细步骤