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)