分布式文件系统使用——MinIO

1 分布式文件系统

1.1 概念

在这里插入图片描述

常见的文件系统：FAT16/FAT32、NTFS、HFS、UFS、APFS、XFS、Ext4等。

现在有个问题，一此短视频平台拥有大量的视频、图片，这些视频文件、图片文件该如何存储呢？如何存储可以满足互联网上海量用户的浏览。
分布式文件系统就是海量用户查阅海量文件的方案。

通过概念可以简单理解为：一个计算机无法存储海量的文件，通过网络将若干计算机组织起来共同去存储海量的文件，去接收海量用户的请求，这些组织起来的计算机通过网络进行通信，如下图：
在这里插入图片描述

分布式文件系统的好处：

一台计算机的文件系统处理能力扩充到多台计算机同时处理
一台计算机挂了还有另外副本计算机提供数据
每台计算机可以放在不同的地域，这样用户就可以就近访问，提高访问速度

总结：干活的人多、有副本、就近访问

1.2 常见的分布式文件系统

①NFS

类比网络上的共享文件夹方式

在这里插入图片描述

1）在客户端上映射NFS服务器的驱动器。
2）客户端通过网络访问NFS服务器的硬盘完全透明。

②GFS（google）

主从结构：master、chunkserver

在这里插入图片描述

1）GFS采用主从结构，一个GFS集群由一个master和大量的chunkserver组成。
2）master存储了数据文件的元数据，一个文件被分成了若干块存储在多个chunkserver中。
3）用户从master中获取数据元信息，向chunkserver存储数据。

③HDFS

HDFS，是Hadoop Distributed File System的简称，是Hadoop抽象文件系统的一种实现。HDFS是一个高度容错性的系统，适合部署在廉价的机器上。HDFS能提供高吞吐量的数据访问，非常适合大规模数据集上的应用。 HDFS的文件分布在集群机器上，同时提供副本进行容错及可靠性保证。例如客户端写入读取文件的直接操作都是分布在集群各个机器上的，没有单点性能压力。

在这里插入图片描述

1）HDFS采用主从结构，一个HDFS集群由一个名称结点和若干数据结点组成。
2) 名称结点存储数据的元信息，一个完整的数据文件分成若干块存储在数据结点。
3）客户端从名称结点获取数据的元信息及数据分块的信息，得到信息客户端即可从
数据块来存取数据。

④云计算厂家（类似：阿里的OOS）

阿里云对象存储服务（Object Storage Service，简称 OSS），是阿里云提供的海量、安全、低成本、高可靠的云存储服务。

百度对象存储BOS提供稳定、安全、高效、高可扩展的云存储服务。

⑤MinIO（去中心化）

MinIO 是一个非常轻量的服务,可以很简单的和其他应用的结合使用，它兼容亚马逊 S3 云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等。
它一大特点就是轻量，使用简单，功能强大，支持各种平台，单个文件最大5TB，兼容 Amazon S3接口，提供了 Java、Python、GO等多版本SDK支持。

2 MinIO教程

2.1 MinIO概念

MinIO是一个轻量级的服务，但是服务功能齐全，我们日常的小项目可以用它来做我们的分布式文件系统。

官网：https://min.io
中文：https://www.minio.org.cn/，http://docs.minio.org.cn/docs/

MinIO集群采用去中心化共享架构，每个结点是对等关系，通过Nginx可对MinIO进行负载均衡访问。

在大数据领域，通常的设计理念都是无中心和分布式。Minio分布式模式可以帮助你搭建一个高可用的对象存储服务，你可以使用这些存储设备，而不用考虑其真实物理位置。
它将分布在不同服务器上的多块硬盘组成一个对象存储服务。由于硬盘分布在不同的节点上，分布式Minio避免了单点故障。

结构图如下：
在这里插入图片描述

Minio使用纠删码技术来保护数据，它是一种恢复丢失和损坏数据的数学算法，它将数据分块冗余的分散存储在各各节点的磁盘上，所有的可用磁盘组成一个集合
使用纠删码的好处是即便丢失一半数量（N/2）的硬盘，仍然可以恢复数据。比如上边集合中有4个以内的硬盘损害仍可保证数据恢复，不影响上传和下载，如果多于一半的硬盘坏了则无法恢复。

如上图，一共4个server，如果有1个server挂了，依然可以上传和下载文件，并且当挂
掉的server恢复后，会自动恢复数据。
"如果多于一半的server挂了，那么无法恢复"，比如：如果有两个挂了，就算server重
新上线，也依然无法恢复数据，数据将无法同步，这对分布式文件系统DFS是致命的。

2.2 使用MinIO

从MinIO官网下载对应操作系统版本，这里以windows为例

①下载好后，创建存放文件的目标文件夹，进入MinIO的cmd执行以下命令

照理来说是应该有多台机器的，但是由于条件限制，采用创建几个文件夹来模拟分布式【大家可以通过虚拟机的方式模拟】

此处我创建四个data文件：
执行命令完成映射：

minio.exe server D:\develop\minio_data\data1 D:\develop\minio_data\data2 D:\develop\minio_data\data3 D:\develop\minio_data\data4

在这里插入图片描述

输入url，进入minio的管理页面

复制上面cmd窗口中展示的任意一个url【端口为：9000】
例如：http://169.254.133.199:9000
用户名、密码默认都是：minioadmin

在这里插入图片描述
②创建bucket

下一步创建bucket，桶，它相当于存储文件的目录，可以创建若干的桶

在这里插入图片描述
③点击“upload”上传文件。

④观察本地四个data目录情况

我们发现上传的1.mp4文件存储在了四个目录，即四个硬盘上。
下边测试minio的数据恢复过程：
1、首先删除一个目录。
删除目录后仍然可以在web控制台上传文件和下载文件。
稍等片刻删除的目录自动恢复。
2、删除两个目录。
删除两个目录也会自动恢复。
3、删除三个目录。
由于集合中共有4块硬盘，有大于一半的硬盘损坏数据无法恢复。
此时报错：We encountered an internal error, please try again. (Read failed. Insufficient number of drives online)在线驱动器数量不足。

2.3 Java操作MinIO

MinIO提供多个语言版本SDK的支持，下边找到java版本的文档：
地址：https://docs.min.io/docs/java-client-quickstart-guide.html
最低需求Java 1.8或更高版本:

2.3.1 导入依赖

<dependency>
    <groupId>io.minio</groupId>
    <artifactId>minio</artifactId>
    <version>8.4.3</version>
</dependency>
<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>4.8.1</version>
</dependency>

2.3.2 测试上传

创建bucket
点击“Manage”修改bucket的访问权限，改为public

public，任意人都可访问

创建一个路径：file【如果不创建，运行下面的代码会自动创建】
测试代码

package com.zi.test;

import io.minio.BucketExistsArgs;
import io.minio.MakeBucketArgs;
import io.minio.MinioClient;
import io.minio.UploadObjectArgs;
import io.minio.errors.MinioException;

import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

/**
 * @author zhouYi
 * @description TODO
 * @date 2023/2/14 17:47
 */
public class MinIOTest {

    static MinioClient minioClient =
            MinioClient.builder()
                    //url先择任何一个server
                    .endpoint("http://169.254.133.199:9000")
                    //用户名密码
                    .credentials("minioadmin", "minioadmin")
                    .build();


    //上传文件
    public static void upload() throws IOException, NoSuchAlgorithmException, InvalidKeyException {
        try {
            boolean found =
                    minioClient.bucketExists(BucketExistsArgs.builder()
                            //选择testbucket
                            .bucket("testbucket").build());
            //检查testbucket桶是否创建，没有创建自动创建
            if (!found) {
                minioClient.makeBucket(MakeBucketArgs.builder().bucket("testbucket").build());
            } else {
                System.out.println("Bucket 'testbucket' already exists.");
            }
            //上传hello.txt
            minioClient.uploadObject(
                    UploadObjectArgs.builder()
                            .bucket("testbucket")
                            .object("hello.txt")
                            .filename("D:\\hello.txt")
                            .build());
            //上传hello.txt,上传到txt子目录
            minioClient.uploadObject(
                    UploadObjectArgs.builder()
                            .bucket("testbucket")
                            .object("txt/hello2.txt")
                            .filename("D:\\hello2.txt")
                            .build());
            System.out.println("上传成功");
        } catch (MinioException e) {
            System.out.println("Error occurred: " + e);
            System.out.println("HTTP trace: " + e.httpTrace());
        }

    }

    public static void main(String[] args) throws IOException, NoSuchAlgorithmException, InvalidKeyException {
        upload();
    }


}

上面的参数说明：

在这里插入图片描述
5. 结果

运行main方法，查看结果：
在这里插入图片描述
在MinIO的控制台查看：

http://169.254.133.199:9000

在这里插入图片描述

2.3.3 测试删除

//连接的MinIO服务器同上文
...
//删除文件
public static void delete(String bucket,String filepath)throws IOException, NoSuchAlgorithmException, InvalidKeyException {
    try {

        minioClient.removeObject(
                RemoveObjectArgs.builder().bucket(bucket).object(filepath).build());
        System.out.println("删除成功");
    } catch (MinioException e) {
        System.out.println("Error occurred: " + e);
        System.out.println("HTTP trace: " + e.httpTrace());
    }

}

public static void main(String[] args)throws IOException, NoSuchAlgorithmException, InvalidKeyException {
//  upload();
    delete("testbucket","hello.txt");
    delete("testbucket","txt/hello2.txt");

}
...

在这里插入图片描述

删除成功！

2.3.4 查询文件是否存在

重新上传文件，然后查询文件是否存在，是否存在，下载到本地

在这里插入图片描述

//连接MinIO的服务器同上
...
    //下载文件
    public static void getFile(String bucket,String filepath,String outFile)throws IOException, NoSuchAlgorithmException, InvalidKeyException {
        try {


            try (InputStream stream = minioClient.getObject(
                    GetObjectArgs.builder()
                            .bucket(bucket)
                            .object(filepath)
                            .build());
                 FileOutputStream fileOutputStream = new FileOutputStream(new File(outFile));
            ) {

                // Read data from stream
                IOUtils.copy(stream,fileOutputStream);
                System.out.println("下载成功");
            }

        } catch (MinioException e) {
            System.out.println("Error occurred: " + e);
            System.out.println("HTTP trace: " + e.httpTrace());
        }

    }


    public static void main(String[] args)throws IOException, NoSuchAlgorithmException, InvalidKeyException {
        upload();
//  delete("testbucket","hello.txt");
//  delete("testbucket","txt/hello2.txt");
        getFile("testbucket","txt/hello2.txt","D:\\hello3.txt");
    }
    ...

在这里插入图片描述

2.3.5 全部测试代码

public class MinIOTest {

    static MinioClient minioClient =
            MinioClient.builder()
                    //url先择任何一个server
                    .endpoint("http://169.254.133.199:9000")
                    //用户名密码
                    .credentials("minioadmin", "minioadmin")
                    .build();


    //上传文件
    public static void upload() throws IOException, NoSuchAlgorithmException, InvalidKeyException {
        try {
            boolean found =
                    minioClient.bucketExists(BucketExistsArgs.builder()
                            //选择testbucket
                            .bucket("testbucket").build());
            //检查testbucket桶是否创建，没有创建自动创建
            if (!found) {
                minioClient.makeBucket(MakeBucketArgs.builder().bucket("testbucket").build());
            } else {
                System.out.println("Bucket 'testbucket' already exists.");
            }
            //上传hello.txt
            minioClient.uploadObject(
                    UploadObjectArgs.builder()
                            .bucket("testbucket")
                            .object("hello.txt")
                            .filename("D:\\hello.txt")
                            .build());
            //上传hello.txt,上传到txt子目录
            minioClient.uploadObject(
                    UploadObjectArgs.builder()
                            .bucket("testbucket")
                            .object("txt/hello2.txt")
                            .filename("D:\\hello2.txt")
                            .build());
            System.out.println("上传成功");
        } catch (MinioException e) {
            System.out.println("Error occurred: " + e);
            System.out.println("HTTP trace: " + e.httpTrace());
        }

    }



    //删除文件
    public static void delete(String bucket,String filepath)throws IOException, NoSuchAlgorithmException, InvalidKeyException {
        try {

            minioClient.removeObject(
                    RemoveObjectArgs.builder().bucket(bucket).object(filepath).build());
            System.out.println("删除成功");
        } catch (MinioException e) {
            System.out.println("Error occurred: " + e);
            System.out.println("HTTP trace: " + e.httpTrace());
        }

    }

    //下载文件
    public static void getFile(String bucket,String filepath,String outFile)throws IOException, NoSuchAlgorithmException, InvalidKeyException {
        try {


            try (InputStream stream = minioClient.getObject(
                    GetObjectArgs.builder()
                            .bucket(bucket)
                            .object(filepath)
                            .build());
                 FileOutputStream fileOutputStream = new FileOutputStream(new File(outFile));
            ) {

                // Read data from stream
                IOUtils.copy(stream,fileOutputStream);
                System.out.println("下载成功");
            }

        } catch (MinioException e) {
            System.out.println("Error occurred: " + e);
            System.out.println("HTTP trace: " + e.httpTrace());
        }

    }


    public static void main(String[] args)throws IOException, NoSuchAlgorithmException, InvalidKeyException {
        upload();
//  delete("testbucket","hello.txt");
//  delete("testbucket","txt/hello2.txt");
        getFile("testbucket","txt/hello2.txt","D:\\hello3.txt");
    }
}

2.4 MinIO整合SpringCloud项目

文件上传是众多项目中比较基础的功能，但是其实现起来细节也很多，下面我将通过MinIO实现文件上传。

前置条件；已经导入好了项目，并且搭建好了nacos环境

2.4.1 文件上传controller

SpringWeb提供了注解：@RequestPart,同时指明文件类型consumes = {MediaType.MULTIPART_FORM_DATA_VALUE}

/**
 * 上传文件
 * @param filedata
 * @param folder
 * @param objectName
 * @return
 */
@RequestMapping(value = "/upload/coursefile", consumes = {MediaType.MULTIPART_FORM_DATA_VALUE})
public UploadFileResultDto upload(@RequestPart("filedata")MultipartFile filedata,
                                  @RequestParam(value="folder", required = false) String folder,
                                  @RequestParam(value="objectName", required = false) String objectName){
    Long companyId = 1232141425L;
    //构建参数传给service
    UploadFileParamsDto uploadFileParamsDto = new UploadFileParamsDto();
    //判断文件类型
    String contentType = filedata.getContentType();
    uploadFileParamsDto.setContentType(contentType);
    uploadFileParamsDto.setFileSize(filedata.getSize());
    //contentType中的image/gif、image/jpeg、image/png都包含image
    if(contentType.indexOf("image") >= 0){
        //图片
        uploadFileParamsDto.setFileType("001001");
    }else{
        uploadFileParamsDto.setFileType("001003");
    }
    //文件名称
    uploadFileParamsDto.setFilename(filedata.getOriginalFilename());
    //构建返回对象
    UploadFileResultDto uploadFileResultDto = null;
    try{
        uploadFileResultDto = mediaFileService.uploadFile(companyId, uploadFileParamsDto, filedata.getBytes(), folder,objectName);
    } catch (Exception e) {
        XcPlusException.cast("上传文件过程出错");
    }
    return uploadFileResultDto;
}

2.4.2 文件上传interface、service、minioConfig

①interface

UploadFileResultDto uploadFile(Long companyId, UploadFileParamsDto uploadFileParamsDto, byte[] bytes, String folder, String objectName);

②service

/**
 * 上传文件通用接口
 *
 * @param companyId
 * @param uploadFileParamsDto
 * @param bytes
 * @param folder
 * @param objectName
 * @return
 */
@Override
public UploadFileResultDto uploadFile(Long companyId, UploadFileParamsDto uploadFileParamsDto, byte[] bytes, String folder, String objectName) {
    //获取文件md5值【根据md5可以判断是否是同一文件】
    String fileMd5 = DigestUtils.md5Hex(bytes);
    if (StringUtils.isEmpty(folder)) {
        //如果没有传文件夹，自动按照年月日生成
        folder = getFileFolder(new Date(), true, true, true);
    } else if (folder.indexOf("/") < 0) {
        folder = folder + "/";
    }
    //文件名称
    String filename = uploadFileParamsDto.getFilename();
    if (StringUtils.isEmpty(objectName)) {
        //如果objectName为空，则使用文件的md5值为文件名
        objectName = fileMd5 + filename.substring(filename.lastIndexOf("."));
    }
    //上传到MinIO【文件夹路径+文件名】
    objectName = folder + objectName;
    try {
        //将文件的字节数组转换为字节输入流
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
        String contentType = uploadFileParamsDto.getContentType();
        PutObjectArgs putObjectArgs = PutObjectArgs.builder()
                .bucket(bucket_files)
                .object(objectName)
                //InputStream stream, long objectSize 对象大小, long partSize 分片大小(-1表示5M,最大不要超过5T，最多10000)
                .stream(byteArrayInputStream, byteArrayInputStream.available(), -1)
                .contentType(contentType)
                .build();
        //上传到minio
        minioClient.putObject(putObjectArgs);

        //保存到数据库[存储文件使用的是md5值]
        MediaFiles mediaFiles = mediaFilesMapper.selectById(fileMd5);
        if(mediaFiles == null){
            mediaFiles = new MediaFiles();
            //封装数据
            BeanUtils.copyProperties(uploadFileParamsDto, mediaFiles);
            mediaFiles.setId(fileMd5);
            mediaFiles.setFileId(fileMd5);
            mediaFiles.setCompanyId(companyId);
            mediaFiles.setFilename(filename);
            mediaFiles.setBucket(bucket_files);
            mediaFiles.setFilePath(objectName);
            mediaFiles.setUrl("/" + bucket_files + "/" + objectName);
            mediaFiles.setCreateDate(LocalDateTime.now());
            mediaFiles.setStatus("1");
            mediaFiles.setAuditStatus("002003");
            //插入数据库【文件表】
            mediaFilesMapper.insert(mediaFiles);
        }
        //准备返回数据
        UploadFileResultDto uploadFileResultDto = new UploadFileResultDto();
        BeanUtils.copyProperties(mediaFiles, mediaFiles);
        return uploadFileResultDto;
    }catch (Exception e) {
        log.debug("上传文件失败：{}",e.getMessage());
    }
    return null;
}

//根据日期生成文件夹
private String getFileFolder(Date date, boolean year, boolean month, boolean day) {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    //获取当前日期字符串
    String dataStr = sdf.format(new Date());
    //取出年月日
    String[] arr = dataStr.split("-");
    StringBuffer folderStr = new StringBuffer();
    if (year) {
        folderStr.append(arr[0]);
        folderStr.append("/");
    }
    if (month) {
        folderStr.append(arr[1]);
        folderStr.append("/");
    }
    if (day) {
        folderStr.append(arr[2]);
        folderStr.append("/");
    }
    return folderStr.toString();
}

③minio配置类（从nacos读取配置）

/**
 * @author zhouYi
 * @description Minio配置类，配置Minio客户端
 * @date 2023/2/15 10:18
 */
@Configuration
public class MinioConfig {

    //从nacos读取参数

    //URL
    @Value("${minio.endpoint}")
    private String endpoint;
    //账号
    @Value("${minio.accessKey}")
    private String accessKey;
    //密码
    @Value("${secretKey}")
    private String secretKey;

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