# MinIO的安装使用

MinIO 是一个基于 Apache License v2.0 开源协议的对象存储服务。它兼容亚马逊 S3 云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几 kb 到最大 5T 不等

# 1. 下载

我们可以直接去官网下载: https://docs.min.io/cn (opens new window)，这里介绍 Windows 版本

# 2. 使用

将之前下载的exe程序放到一个地方

启动一个 CMD 窗口，进入 minio.exe 所在文件夹，输入如下命令

.\minio.exe server D:\Tools\minio

这样就启动了，可以访问后台界面: http://127.0.0.1:9000 (opens new window)，Access Key 和 Secret Key 在命令行那有显示，都是 minioadmin

先创建你的 Bucket，Bucket 创建成功之后就可以上传文件了，Bucket 不能含大写字母，我创建了一个名为 file 的 Bucket，点击上传文件

上传成功了，可以点击文件分享，设置多久链接过期

打开链接可以看到读取我们的图片文件了

# 3. Docker

转移到 Docker 专栏: Docker下MinIO的使用

# 4. Linux

这里我使用的是 CentOs，先去官网下载文件，然后传到服务器里

命令如下

# 设置权限
chmod +x minio
# 设置密钥
export MINIO_ACCESS_KEY=minioadmin
export MINIO_SECRET_KEY=miniostorage
# 启动
./minio server /app/minio/data
# 后台启动
nohup /app/minio/minio server /app/minio/data > /app/minio/log/minio.log 2>&1 &
# 查看进程
ps -ef |grep minio
# 杀进程
kill -9 pid

# 5. 集群

/home/tomcat/minio/minio server http://10.5.88.165/home/tomcat/minio/data1 http://10.5.88.165/home/tomcat/minio/data1 \
           http://10.5.88.166/home/tomcat/minio/data1 http://10.5.88.166/home/tomcat/minio/data1

minio server http://192.168.1.11/export1 http://192.168.1.11/export2 \
               http://192.168.1.11/export3 http://192.168.1.11/export4 \

upstream minio {
    server 10.5.88.165:9000 weight=10 max_fails=2 fail_timeout=30s;
    server 10.5.88.166:9000 weight=10 max_fails=2 fail_timeout=30s;
}
   
server {
    listen 9000;
    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;
    }
}

# 6. 代码

pom.xml

<minio.version>6.0.12</minio.version>
<guava.version>20.0</guava.version>
<!-- MinIO文件系统 -->
<dependency>
    <groupId>io.minio</groupId>
    <artifactId>minio</artifactId>
    <version>${minio.version}</version>
</dependency>

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>${guava.version}</version>
</dependency>

MinioConfig

# MinIO文件系统
minio:
  url: http://xx.xx.xx.xxx:9000
  access: minioadmin
  secret: miniostorage
  bucket: pdms

package com.example.config;

import io.minio.MinioClient;
import io.minio.errors.MinioException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.task.TaskExecutor;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.io.ByteArrayInputStream;
import java.util.HashMap;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * Minio文件系统初始化
 *
 * @author wliduo[i@dolyw.com]
 * @date 2020/2/5 14:36
 */
@Configuration
public class MinioConfig {

    /**
     * logger
     */
    private final static Logger logger = LoggerFactory.getLogger(MinioConfig.class);

    @Value("${minio.url}")
    private String url;

    @Value("${minio.access}")
    private String access;

    @Value("${minio.secret}")
    private String secret;

    @Value("${minio.bucket}")
    private String bucket;

    /**
     * Minio文件系统配置
     *
     * @param
     * @return io.minio.MinioClient
     * @throws
     * @author wliduo[i@dolyw.com]
     * @date 2020/2/5 16:10
     */
    @Bean(name = "minioClient")
    public MinioClient minioClient() throws Exception {
        logger.info("---------- Minio文件系统初始化加载 ----------");
        MinioClient minioClient = new MinioClient(url, access, secret);
        // 判断Bucket是否存在
        boolean isExist = minioClient.bucketExists(bucket);
        if(isExist) {
            logger.info("---------- Minio文件系统Bucket已存在 ----------");
        } else {
            // 不存在创建一个新的Bucket
            minioClient.makeBucket(bucket);
            logger.info("---------- Minio文件系统Bucket已创建 ----------");
        }
        logger.info("---------- Minio文件系统初始化完成 ----------");
        return minioClient;
    }

}

MinioUtil

package com.example.util;

import io.minio.MinioClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;

/**
 * MinioUtil工具类
 *
 * @author wliduo[i@dolyw.com]
 * @date 2020/2/5 17:53
 */
@Component
public class MinioUtil {

    /**
     * logger
     */
    private final static Logger logger = LoggerFactory.getLogger(MinioUtil.class);

    @Value("${minio.bucket}")
    private String bucket;

    /**
     * minioClient
     */
    private final MinioClient minioClient;

    @Autowired
    public MinioUtil(MinioClient minioClient) {
        this.minioClient = minioClient;
    }

    /**
     * 上传文件
     *
     * @param file
     * @return java.lang.String
     * @throws
     * @author wliduo[i@dolyw.com]
     * @date 2020/2/6 16:03
     */
    public String uploadFile(MultipartFile file) {
        try(ByteArrayInputStream bais = new ByteArrayInputStream(file.getBytes())) {
            return uploadFile(bais, file.getOriginalFilename());
        } catch (IOException e) {
            logger.error("{}文件上传失败", file.getOriginalFilename());
            return "";
        }
    }

    /**
     * 上传文件
     *
     * @param stream
     * @param fileName
     * @return java.lang.String
     * @throws
     * @author wliduo[i@dolyw.com]
     * @date 2020/2/6 16:04
     */
    public String uploadFile(InputStream stream, String fileName) {
        // 获取当前日期，设置文件夹
        LocalDateTime localDateTime = LocalDateTime.now();
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy/MM/dd/");
        // 上传文件路径
        StringBuilder objectName = new StringBuilder(localDateTime.format(dateTimeFormatter));
        objectName.append('[').append(System.currentTimeMillis()).append(']').append(fileName);
        try {
            // 上传文件
            minioClient.putObject(bucket, objectName.toString(), stream, new HashMap(16));
            return objectName.toString();
        } catch (Exception e) {
            logger.error("{}文件上传失败", objectName);
            return "";
        }
    }

    /**
     * 获取文件
     *
     * @param objectName
     * @return java.io.InputStream
     * @throws
     * @author wliduo[i@dolyw.com]
     * @date 2020/2/6 16:05
     */
    public InputStream getFile(String objectName) {
        try {
            // 文件是否存在
            minioClient.statObject(bucket, objectName);
            // 获取文件
            return minioClient.getObject(bucket, objectName);
        } catch (Exception e) {
            logger.error("{}文件获取失败", objectName);
            return null;
        }
    }

    /**
	 * 直接下载文件
	 * 
	 * @param req
	 * @param res
	 * @param fid
	 * @param fileName
	 * @return void
	 * @throws 
	 * @author wliduo[i@dolyw.com]
	 * @date 2020/3/5 9:45
	 */
    public void lookUploadFile(HttpServletRequest req, HttpServletResponse res, String fid, String fileName) {
		try (InputStream in = minioUtil.getFile(fid);
			 OutputStream output = res.getOutputStream()) {
			// 得到输入流
			if (in == null) {
				try (PrintWriter printWriter = res.getWriter()) {
					printWriter.append("404 - File Not Exist");
				} catch (IOException e) {
					logger.error("数据异常: {}", e);
				}
				return;
			}
			res.reset();
			// res.setContentType(getMimeType(fileName));
            // https://gitee.com/dolyw/codes/2h1r6avwxumegjs89ztyn86
			res.addHeader("content-Disposition", "inline;filename=" + java.net.URLEncoder.encode(fileName, "UTF-8"));
			byte[] b = new byte[4096];
			int i = 0;
			while ((i = in.read(b)) > 0) {
				output.write(b, 0, i);
			}
		} catch (MalformedURLException me) {
			logger.error("数据异常: {}", me);
		} catch (IOException e) {
			logger.error("数据异常: {}", e);
		}
	}

    /**
     * 获取外链
     *
     * @param objectName
     * @return java.lang.String
     * @throws
     * @author wliduo[i@dolyw.com]
     * @date 2020/2/6 16:04
     */
    public String getFileUrl(String objectName) {
        try {
            return minioClient.presignedGetObject(bucket, objectName, 60 * 60 * 24);
        } catch (Exception e) {
            logger.error("{}文件获取失败", objectName);
            return "";
        }
    }
}

参考

← 文件系统了解及对比选型 FastDFS的安装使用 →