minio-分布式文件存储系统

原创已于 2024-01-17 17:17:44 修改 · 1.5k 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#分布式

于 2023-08-01 16:46:12 首次发布

Java开发专栏收录该内容

19 篇文章

订阅专栏

本文介绍了Minio作为一款基于ApacheLicensev2.0的分布式文件存储系统，其特点包括数据保护、高性能、可扩展性、丰富的SDK支持和易于管理的用户界面。文章还展示了如何在Docker中部署Minio以及在SpringBoot中整合使用的方法。

minio-分布式文件存储系统

在这里插入图片描述

minio的简介

MinIO基于Apache License v2.0开源协议的对象存储服务，可以做为云存储的解决方案用来保存海量的图片，视频，文档。由于采用Golang实现，服务端可以工作在Windows,Linux, OS X和FreeBSD上。配置简单，基本是复制可执行程序，单行命令可以运行起来。

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

minio的特点

数据保护

Minio使用Minio Erasure Code（纠删码）来防止硬件故障。即便损坏一半以上的driver，但是仍然可以从中恢复。

高性能

作为高性能对象存储，在标准硬件条件下它能达到55GB/s的读、35GB/s的写速率

可扩容

不同MinIO集群可以组成联邦，并形成一个全局的命名空间，并跨越多个数据中心

SDK支持

基于Minio轻量的特点，它得到类似Java、Python或Go等语言的sdk支持

有操作页面

面向用户友好的简单操作界面，非常方便的管理Bucket及里面的文件资源

功能简单

这一设计原则让MinIO不容易出错、更快启动

丰富的API

支持文件资源的分享连接及分享链接的过期策略、存储桶操作、文件列表访问及文件上传下载的基本功能等。

文件变化主动通知

存储桶（Bucket）如果发生改变,比如上传对象和删除对象，可以使用存储桶事件通知机制进行监控，并通过以下方式发布出去:AMQP、MQTT、 Elasticsearch、Redis、NATS、MySQL、Kafka、Webhooks等。

minio部署（docker）

创建文件目录

mkdir -p /export/server/docker/minio/data
mkdir -p /export/server/docker/minio/config

docker run -p 9000:9000 -p 9090:9090 \
 --net=host \
 --name minio \
 -d --restart=always \
 -e "MINIO_ACCESS_KEY=minioadmin" \
 -e "MINIO_SECRET_KEY=minioadmin" \
 -v  /export/server/docker/minio/data:/data \
 -v  /export/server/docker/minio/config:/root/.minio \
 minio/minio server \
 /data --console-address ":9090" -address ":9000"

访问地址：http://ip:9090 用户名：minioadmin 密码：minioadmin

在这里插入图片描述

springboot整合minio

maven依赖

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

minio工具类

import com.naseng.common.utils.DateUtils;
import com.naseng.common.utils.StringUtils;
import io.minio.*;
import io.minio.http.Method;
import io.minio.messages.Bucket;
import io.minio.messages.Item;
import org.springframework.mock.web.MockMultipartFile;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/***
 * minio工具类<br/>
 * 注意事项：minio服务器的时间必须和调用者时间保持一致，
 *
 */
public class MinIoUtil {

    private static String endpoint = "http://192.168.88.100:9000";
    private static String accessKey = "B76JBXDGITSR79Q3J1ZA";
    private static String secretKey = "1pseOc+tbvLpXe5kcWWzC8GA5SxVUIDFu46jNnIj";
    private static String bucketName = "myminio";

    private static MinioClient minioClient;

    static {
        minioClient = MinioClient.builder()
            .endpoint(endpoint)
            .credentials(accessKey, secretKey)
            .build();
    }

    public static void main(String[] args) {
        MinIoUtil minIoUtil = new MinIoUtil();
//        List<Bucket> allBuckets = minIoUtil.getAllBuckets();
//        for (Bucket allBucket : allBuckets) {
//            System.out.println(allBucket.name());
//        }
//        String upload = minIoUtil.upload(new File("E:\\360MoveData\\Users\\EDY\\Desktop\\20240111\\S8-diff-20231218[20231222-13_48_01]93.zip"));
//        System.out.println(upload);

        String preview = minIoUtil.preview("2024-01-17/1705481963007.zip");
        System.out.println(preview);

    }

    /**
     * 创建存储bucket
     *
     * @param bucketName 存储桶
     * @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 存储桶
     * @return Boolean
     */
    public Boolean removeBucket(String bucketName) {
        try {
            minioClient.removeBucket(RemoveBucketArgs.builder()
                .bucket(bucketName)
                .build());
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 获取全部bucket
     */
    public List<Bucket> getAllBuckets() {
        try {
            return minioClient.listBuckets();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 文件上传
     *
     * @param file 文件
     * @return Boolean
     */
    public String upload(MultipartFile file) {
        String originalFilename = file.getOriginalFilename();
        if (StringUtils.isBlank(originalFilename)) {
            throw new RuntimeException();
        }
        String fileName = System.currentTimeMillis() + originalFilename.substring(originalFilename.lastIndexOf("."));
        String objectName = DateUtils.parseDateToStr("yyyy-MM-dd", new Date()) + "/" + fileName;
        try {
            PutObjectArgs objectArgs = PutObjectArgs.builder().bucket(bucketName).object(objectName)
                .stream(file.getInputStream(), file.getSize(), -1).contentType(file.getContentType()).build();
            //文件名称相同会覆盖
            minioClient.putObject(objectArgs);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
        return objectName;
    }

    /**
     * 文件上传
     *
     * @param file 文件
     * @return Boolean
     */
    public String upload(File file) {
        MultipartFile multipartFile = fileToMultipartFile(file);
        return upload(multipartFile);
    }

    /**
     * 预览图片
     *
     * @param fileName
     * @return
     */
    public String preview(String fileName) {
        // 查看文件地址
        GetPresignedObjectUrlArgs build = new GetPresignedObjectUrlArgs().builder().bucket(bucketName).object(fileName).method(Method.GET).build();
        try {
            return minioClient.getPresignedObjectUrl(build);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 查看文件对象
     *
     * @return 存储bucket内文件对象信息
     */
    public List<Item> listObjects() {
        Iterable<Result<Item>> results = minioClient.listObjects(
            ListObjectsArgs.builder().bucket(bucketName).build());
        List<Item> items = new ArrayList<>();
        try {
            for (Result<Item> result : results) {
                items.add(result.get());
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
        return items;
    }

    /**
     * 删除
     *
     * @param fileName
     * @return
     * @throws Exception
     */
    public boolean remove(String fileName) {
        try {
            minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(fileName).build());
        } catch (Exception e) {
            return false;
        }
        return true;
    }

    /**
     * file转MultipartFile <br></br>
     * <p>使用MockMultipartFile类需要引入</p>
     * <br></br>
     * <dependency>
     * <groupId>org.springframework</groupId>
     * <artifactId>spring-test</artifactId>
     * </dependency>
     *
     * @param file file
     * @return MultipartFile
     */
    public static MultipartFile fileToMultipartFile(File file) {
        MultipartFile result = null;
        try (FileInputStream input = new FileInputStream(file)) {
            result = new MockMultipartFile(file.getName().concat("temp"), file.getName(), "text/plain", input);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return result;
    }

}