开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 系统运维 -> minio单机、集群搭建、Spring Boot集成，详细步骤 -> 正文阅读

[系统运维]minio单机、集群搭建、Spring Boot集成，详细步骤

一、单机minio搭建

1.下载rpm包

下载地址：https://dl.min.io/server/minio/release/linux-amd64/

?2.安装

rpm -ivh minio-20220504074527.0.0.x86_64.rpm

?修改 /etc/systemd/system/minio.service文件

#启动的用户和用户组
User=root
Group=root
#配置文件地址
EnvironmentFile=-/etc/default/minio.conf

?创建配置文件并编辑：

#创建文件存储路径
mkdir -p /opt/minio/data

#创建并编辑配置文件
touch /etc/default/minio.conf
vi /etc/default/minio.conf

#编辑内容，请确保MINIO_VOLUMES（文件存储）路径存在
MINIO_VOLUMES="/opt/minio/data"
MINIO_OPTS="--address :9001 --console-address :9000"
MINIO_ACCESS_KEY=minioadmin
MINIO_SECRET_KEY=minioadmin

安装完成，启动，并查看状态：

#重新刷新
systemctl daemon-reload
#，启动
systemctl start minio
#查看状态
systemctl status minio

?3.浏览器访问：http://ip:9000

若无法访问则关闭防火墙或打开端口

?使用刚刚配置的账户信息登陆即可。

二、minio集群搭建

服务器	挂载磁盘路径
192.168.14.131	/data/minio_data
192.168.14.133	/data/minio_data
192.168.14.134	/data/minio_data
192.168.14.136	/data/minio_data

请在操作前关闭防火墙，保证服务器间端口通信正常，并保证时间同步

时间同步：

yum -y install ntp
ntpdate ntp1.alliyun.com
#开启自动同步
service ntpd start
#开机自启同步
systemctl enable ntpd

1.创建minio存储路径（4台机器均要执行）

mkdir -p /data/minio_data

2.挂载磁盘（4台机器均要执行）

?硬盘添加完成后输入：

fdisk -l

?如果没有看见底部对应磁盘，重启服务器后可见。

看到新磁盘/dev/sdb后，开始进行分区及格式化

#依次输入
fdisk  /dev/sdb
m
n
p
1
#回车即可，出现下图后输入w

fdisk -l

?格式化成ext3的文件系统

mkfs -t ext3 /dev/sdb1
#自动挂载
vi /etc/fstab
#添加以下内容
/dev/sdb1          /data/minio_data        ext3    defaults        0 1

#使刚才设置指令生效
mount -a
df -h

?注意：挂载后不要在/data/minio_data下放任何文件，挂载自动生成的lost+found可忽略。

2.创建文件（4台机器均要执行）

mkdir -p /data/minio/run/

3.下载minio文件（4台机器均要执行）

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

将minio文件移到/data/minio/run/路径下

mv minio /data/minio/run/minio

4.编辑启动脚本（4台机器均要执行）

vi /data/minio/run/run.sh

#以下为文件内容
#!/bin/bash
export MINIO_ROOT_USER=minioadmin
export MINIO_ROOT_PASSWORD=minioadmin

/data/minio/run/minio server  --config-dir /etc/minio --address ":9000" --console-address ":9001" \
http://192.168.14.131/data/minio_data \
http://192.168.14.133/data/minio_data \
http://192.168.14.134/data/minio_data \
http://192.168.14.136/data/minio_data

注意里面的#!/bin/bash，不加的话后续使用服务启动会直接结束，会出现

main process exited, code=exited, status=203/EXEC

5.创建Minio.server,将minio加入系统服务（4台机器均要执行）

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

#以下为文件内容
[Unit]
Description=Minio service
Documentation=https://docs.minio.io/

[Service]
WorkingDirectory=/data/minio/run/
ExecStart=/data/minio/run/run.sh

Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target

赋予权限：

chmod +x /usr/lib/systemd/system/minio.service && chmod +x /data/minio/run/minio && chmod +x /data/minio/run/run.sh

6.启动集群：

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

#重新刷新
systemctl daemon-reload
#启动，需在每台执行，需依照启动脚本里的服务器顺序执行
systemctl start minio.service


#4台服务器都执行启动命令后，过一段时间再查看状态，监听并连通需要几秒时间
systemctl status minio.service -l

若启动不成功，可采用/data/minio/run/run.sh直接启动，查看输出内容。

启动成功的界面如下图所示：

?浏览器访问即可看见：

三、Spring boot集成minio

pom.xml

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

配置文件：

#指向API地址，非控制台地址
minio.url=http://192.168.14.135:9001
minio.accessKey=minioadmin
minio.secretKey=minioadmin
#文件桶名称
minio.bucketName=minuploadfiles

MinIoClientConfig.java

package MinioUtils;

import io.minio.MinioClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

@Component
public class MinIoClientConfig {
    @Value("${minio.url}")
    private String url;
    @Value("${minio.accessKey}")
    private String accessKey;
    @Value("${minio.secretKey}")
    private String secretKey;

    /**
     * 注入minio 客户端
     * @return
     */
    @Bean
    public MinioClient minioClient(){

        return MinioClient.builder()
                .endpoint(url)
                .credentials(accessKey, secretKey)
                .build();
    }
}

ObjectItem.java

package MinioUtils;

public class ObjectItem {
    private String objectName;
    private Long size;

    public String getObjectName() {
        return objectName;
    }

    public void setObjectName(String objectName) {
        this.objectName = objectName;
    }

    public Long getSize() {
        return size;
    }

    public void setSize(Long size) {
        this.size = size;
    }
}

MinioHelp.java

package MinioUtils;

import baseUtils.MyException;
import baseUtils.ResultEnum;
import common.SystemConfig;
import io.minio.*;
import io.minio.messages.DeleteError;
import io.minio.messages.DeleteObject;
import io.minio.messages.Item;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

import java.io.*;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

@Component
public class MinioHelp {
    private final static Logger logger  = LoggerFactory.getLogger(MinioHelp.class);

    @Autowired
    private MinioClient minioClient;
    /**
     * description: 判断bucket是否存在，不存在则创建
     *
     * @return: void
     */
    public void existBucket(String name) {
        try {
            boolean exists = minioClient.bucketExists(BucketExistsArgs.builder().bucket(name).build());
            if (!exists) {
                minioClient.makeBucket(MakeBucketArgs.builder().bucket(name).build());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 创建存储bucket
     * @param bucketName 存储bucket名称
     * @return Boolean
     */
    public Boolean makeBucket(String bucketName) {
        try {
            minioClient.makeBucket(MakeBucketArgs.builder()
                    .bucket(bucketName)
                    .build());
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 删除存储bucket
     * @param bucketName 存储bucket名称
     * @return Boolean
     */
    public Boolean removeBucket(String bucketName) {
        try {
            minioClient.removeBucket(RemoveBucketArgs.builder()
                    .bucket(bucketName)
                    .build());
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }
    /**
     * description: 上传多个文件
     *
     * @param multipartFile
     * @return: java.lang.String

     */
    public List<String> upload(List<MultipartFile> multipartFile) {
        List<String> names = new ArrayList<>(multipartFile.size());
        String bucketName= SystemConfig.getProperty("minio.bucketName");
        for (int i = 0; i < multipartFile.size(); i++) {
            MultipartFile file=multipartFile.get(i);
            String fileName = file.getOriginalFilename();
            String[] split = fileName.split("\\.");
            if (split.length > 1) {
                fileName = split[0] + "_" + System.currentTimeMillis() + "." + split[1];
            } else {
                fileName = fileName + System.currentTimeMillis();
            }
            InputStream in = null;
            try {
                in = file.getInputStream();
                minioClient.putObject(PutObjectArgs.builder()
                        .bucket(bucketName)
                        .object(fileName)
                        .stream(in, in.available(), -1)
                        .contentType(file.getContentType())
                        .build()
                );
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (in != null) {
                    try {
                        in.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            names.add(fileName);
        }
        return names;
    }

    /**
     * description: 上传单个文件
     */
    public boolean uploadOne(String fileName,MultipartFile file) {
        String bucketName= SystemConfig.getProperty("minio.bucketName");
        InputStream in = null;
        boolean isSucceed =false;
        try {
            in = file.getInputStream();
            minioClient.putObject(PutObjectArgs.builder()
                    .bucket(bucketName)
                    .object(fileName)
                    .stream(in, in.available(), -1)
                    .contentType(file.getContentType())
                    .build()
            );
            isSucceed=true;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return isSucceed;
    }

    /**
     * description: 下载文件
     *
     * @param fileName
     * @return: org.springframework.http.ResponseEntity<byte [ ]>
     */
    public ResponseEntity<byte[]> download(String fileName) {
        ResponseEntity<byte[]> responseEntity = null;
        InputStream in = null;
        ByteArrayOutputStream out = null;
        String bucketName= SystemConfig.getProperty("minio.bucketName");
        try {
            in = minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(fileName).build());
            out = new ByteArrayOutputStream();
            IOUtils.copy(in, out);
            //封装返回值
            byte[] bytes = out.toByteArray();
            HttpHeaders headers = new HttpHeaders();
            try {
                headers.add("Content-Disposition", "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8"));
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
            headers.setContentLength(bytes.length);
            headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
            headers.setAccessControlExposeHeaders(Arrays.asList("*"));
            responseEntity = new ResponseEntity<byte[]>(bytes, headers, HttpStatus.OK);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (in != null) {
                    try {
                        in.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (out != null) {
                    out.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return responseEntity;
    }

    /**
     * 查看文件对象
     * @param bucketName 存储bucket名称
     * @return 存储bucket内文件对象信息
     */
    public List<ObjectItem> listObjects(String bucketName) {
        Iterable<Result<Item>> results = minioClient.listObjects(
                ListObjectsArgs.builder().bucket(bucketName).build());
        List<ObjectItem> objectItems = new ArrayList<>();
        try {
            for (Result<Item> result : results) {
                Item item = result.get();
                ObjectItem objectItem = new ObjectItem();
                objectItem.setObjectName(item.objectName());
                objectItem.setSize(item.size());
                objectItems.add(objectItem);
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
        return objectItems;
    }

    /**
     * 批量删除文件对象
     * @param bucketName 存储bucket名称
     * @param objects 对象名称集合
     */
    public Iterable<Result<DeleteError>> removeObjects(String bucketName, List<String> objects) {
        List<DeleteObject> dos = objects.stream().map(e -> new DeleteObject(e)).collect(Collectors.toList());
        Iterable<Result<DeleteError>> results = minioClient.removeObjects(RemoveObjectsArgs.builder().bucket(bucketName).objects(dos).build());
        return results;
    }

    // 下载文件InputStream
    public InputStream downloadInput(String fileName){
        String bucketName= SystemConfig.getProperty("minio.bucketName");
        try {
            return minioClient.getObject(GetObjectArgs
                                         .builder()
                                         .bucket(bucketName)
                                         .object(fileName)
                                         .build());
        } catch (Exception e) {
            e.printStackTrace();
            throw new MyException(ResultEnum.FAST_DFS_ERROR);
        }
    }

    //保存文件到服务器
    public String downFileToLocal(String fileName){
        InputStream is =downloadInput(fileName);
        String pathStr= SystemConfig.getProperty("SavePath");
        String FolderStr = "imptemp";
        String wholePath = pathStr + "uploadfiles" + (StringUtils.isBlank(FolderStr) ? "" : "/" + FolderStr+"/"+fileName);
        File file = new File(wholePath);
        logger.info("wholePath="+wholePath);
        if(!file.exists()) {
            if (!file.getParentFile().exists()) {
                file.getParentFile().mkdirs();
            }
            try {
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        try {
            BufferedInputStream in=null;
            BufferedOutputStream out=null;
            in=new BufferedInputStream(is);
            out=new BufferedOutputStream(new FileOutputStream(wholePath));
            int len=-1;
            byte[] b=new byte[1024];
            while((len=in.read(b))!=-1){
                out.write(b,0,len);
            }
            in.close();
            out.close();
            return wholePath;
        } catch (Exception e) {
            e.printStackTrace();
            throw new MyException(ResultEnum.FAST_DFS_ERROR);
        }
    }
}

使用示例：

    @Autowired
    private MinioHelp minioHelp;
    
    //上传文件
    @PostMapping("/MinioFileUpload.action")
    public Object uploadFileInMinio(HttpServletRequest request){
        logger.info("MinioFileUpload");
	    List<MultipartFile> files = ((MultipartHttpServletRequest) request).getFiles("file");

        List<Map<String,String>> result=new ArrayList<Map<String,String>>();
	    for (int i = 0; i < files.size(); i++) {
	        MultipartFile file = files.get(i);
            String newFileName =new Date().getTime()+ i+"." + extName;
            try {
            	#上传文件
                boolean isSucceed=minioHelp.uploadOne(newFileName,files.get(i));
                if(!isSucceed){
                    throw new MyException(1037,"文件\""+fileName+"\"上传失败");
                }

            }catch (Exception e) {
                e.printStackTrace();
                throw new MyException(ResultEnum.FILE_UPLOAD_FAIL);
            }
        }
        return ResultVOUtil.success(result);
    }
    
    //拉取文件到服务器
    public void downFileToLocal(String fileName){
    	MinioHelp.downFileToLocal(oldFileName);
    }