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集成，详细步骤

posted @ 2022-06-06 22:50 张瑞丰阅读(4453) 评论(0) 编辑收藏举报

刷新页面返回顶部

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

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

1、搭建服务端(单点)

1.1、下载

1.2、授权

1.3、启动服务端

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

1.5、开放端口号

1.6、验证

2、搭建客户端

2.1、下载

2.2、授权

2.3、设置桶的读写权限

3、集群搭建

3.1、机器资源

3.2、集群配置

3.3、注册开机自启

3.3.1、编写启动脚本

3.3.2、开放端口：

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

3.4、配置桶永久下载地址

3.5、验证

4、配置Nginx

5、SpringBoot集成Minio

公告