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

已于 2023-02-15 11:08:39 修改
阅读量3k 收藏 7
点赞数 1
分类专栏： 框架 文章标签： hadoop java 大数据 分布式文件系统 MinIO
于 2023-02-15 08:27:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45565886/article/details/129029984
版权

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

1 分布式文件系统

1.1 概念

在这里插入图片描述

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

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

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

分布式文件系统的好处：

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

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避免了单点故障。

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

  1. Minio使用纠删码技术来保护数据，它是一种恢复丢失和损坏数据的数学算法，它将数据分块冗余的分散存储在各各节点的磁盘上，所有的可用磁盘组成一个集合
  2. 使用纠删码的好处是即便丢失一半数量（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 测试上传
  1. 创建bucket
    在这里插入图片描述
  2. 点击“Manage”修改bucket的访问权限，改为public
    在这里插入图片描述
    在这里插入图片描述

public，任意人都可访问

  1. 创建一个路径：file【如果不创建，运行下面的代码会自动创建】
    在这里插入图片描述

  2. 测试代码

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;
    }
}
NPE~
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java分布式文件对象存储Minio框架并发上传、下载、合并、删除等操作示例Demo完整版
08-01
Java分布式文件对象存储Minio框架并发上传、下载、合并、删除等操作示例Demo完整版，可用于生产环境开发。
Minio 文件服务（1）—— Minio部署使用及存储机制分析
huangbaoling66的博客
05-13 7736
Minio 文件服务（1）—— Minio部署使用及存储机制分析 Minio 文件服务（2）—— Minio用Nginx做负载均衡 本文参考Minio官方文档，使用细节里面说的很详细，本文主要讲解文档中较少涉及的Minio存储机制。以及我在使用中部署和使用Java SDK访问的过程。 简介 Minio 是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储...
使用minio进行文件存储
学习总结
03-08 977
MinIO是一个开源的分布式对象存储服务器，支持S3协议并且可以在多节点上实现数据的高可用和容错。它采用Go语言开发，拥有轻量级、高性能、易部署等特点，并且可以自由选择底层存储介质。它基于Apache License 开源协议，兼容Amazon S3云存储接口。适合存储非结构化数据，如图片，音频，视频，日志等。
Minio快速入门
最新发布
qq_62646841的博客
03-17 763
官网：https://www.minio.org.cn/1、高性能：MinIO基于GO语言编写，具有高速、轻量级、高并发等性能特点，还支持多线程和缓存等机制进行优化，可以快速地处理大规模数据。2、安装部署简单：MinIO只需要执行这几行命令便可轻松搞定，也大大降低了学习和维护成本。3、操作简单，自带管理界面：MinIO在服务端安装后就自带了UI界面，可谓开箱即用。
minio 分布式文件存储系统 windows版本
05-16
minio分布式文件存储系统， 20221228_windows 官网比较难下载，备份一个程序，需要的拿去用
安装MinIO和使用MinIO Java SDK实现对文件的基本操作
cn_ljr的博客
01-14 3761
CentOS7下安装MinIO，使用MinIO Java SDK实现基本的文件上传、删除和下载操作
高性能对象存储minio
墨家巨子@俏如来
08-17 9435
MinIO 是在 Apache License v2.0 下发布的高性能对象存储。 它是与 Amazon S3 云存储服务兼容的 API。MinIO 是一个高性能的对象存储原生支持 Kubernetes 部署的解决方案。
Minio入门
huangbaokang的博客
01-28 7365
中文文档地址https://docs.min.io/cn/ 简介 MinIO 是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几kb到最大5T不等。 MinIO是一个非常轻量的服务,可以很简单的和其他应用的结合，类似 NodeJS, Redis 或者 MySQL。 安装方式，官网提供了好多方式，由基于docker安装，不同操作系统
​ MinIO​使用
weixin_51319734的博客
06-20 4059
是对象存储服务,它基于Apache License 开源协议，兼容Amazon S3云存储接口。适合存储非结构化数据，如图片，音频，视频，日志等。对象文件最大可以达到5TB。类似于腾讯的oss或者阿里的对象存储平台，适用于解决分布式云存储。
MinIo简单使用
热门推荐
six_teen的博客
05-23 1万+
对于项目的文件存储可以使用像阿里云、腾讯云这种平台的服务，当然也可以自己搭建一个文件管理系统。这里简单介绍一下MinIo 官网地址: http://www.minio.org.cn/ 先根据官网地址进行下载MinIo的server端和client端，这里需要注意一点的是，在官网给的下载地址：http://dl.minio.org.cn/server/minio/release/windows-amd64/minio.exe https://dl.minio.org.cn/client/mc/release/
minio报错：Unable to use the drive /data: invalid argument
qq_37106501的博客
09-07 1万+
minio
springboot集成minio完成自己的分布式文件系统
02-28
springboot集成minio完成自己的分布式文件系统，在也不需要付费的了
分布式的对象存储系统MinIO的客户端mc
06-05
本文件是分布式对象存储系统MinIO的客户端mc,可用于在Prometheus对MinIO监控时，MinIO中的Prometheus端点默认需要身份验证。Prometheus支持使用承载令牌方法对Prometheus抓取请求进行身份验证，并使用**mc**生成的...
高性能、分布式的对象存储系统MinIO
06-05
MinIO 是一款高性能、分布式的对象存储系统，能够它能够更简单的实现局有弹性伸缩能力的原生对象存储服务，具有高性能，可扩展，简单特性，主要在微服务系统中使用
m1MAC使用nginx上传图片至minIO时显示500 Internal Server Error错误解决
Dream的博客
08-17 464
在检查网页网络后，发现响应： <html> <head><title>500 Internal Server Error</title></head> <body> <center><h1>500 Internal Server Error</h1></center> <h...
如何利用minio实现文件上传存储？
ouyangsong的博客
08-09 6757
一、将minio部署在docker容器中 <1> 安装好docker容器后，运行下面的命令。如果之前没有安装过minio镜像，则会自动安装并且启动一个容器。这里-p指定了两个端口，前者是api方式访问的端口，后者是客户端界面访问的端口。-e指定的是登录的账号密码。 docker run -p 9008:9000 -p 9007:9007 --name minio \ -d --restart=always \ -e "MINIO_ACCESS_KEY=minioadmin" \ -e "
MinIO的使用
weixin_48692396的博客
02-27 3078
MinIO概述官网地址：https://minio.org.cnMinIO是一款基于Apache License v2.0开源协议的分布式文件系统（或者叫对象存储服务），可以做为云存储的解决方案用来保存海量的图片、视频、文档等。由于采用Golang实现，服务端可以工作在Windows、Linux、 OS X和FreeBSD上。配置简单，基本是复制可执行程序，单行命令就可以运行起来。
Minio如何使用（分布式文件存储）
weixin_47162914的博客
09-14 1530
Minio分布式文件存储，使用java操作Minio传输文件。
Minio文件存储服务使用教程详解（附Java工具类）
Q36_524的博客
10-21 2679
Minio分布式文件存储使用教程
minio分布式文件系统
07-07
Minio是一个开源的分布式对象存储服务器，它实现了Amazon S3云存储服务的API。它可以在一个集群中部署多个节点，提供高可用性、可扩展性和数据冗余。Minio的设计目标是简单、易用，它可以在本地服务器或云环境中运行。 使用Minio，你可以通过HTTP接口上传、下载和管理对象（文件）。它支持多租户、访问控制、版本控制和数据加密等功能。你可以使用Minio来构建自己的私有云存储服务，也可以将其作为存储后端集成到其他应用中。 Minio的分布式特性使得它能够在集群中自动复制数据，提供数据冗余和故障恢复。它采用了一种称为Erasure Code的技术来实现数据的冗余存储，确保数据的可靠性和可用性。 总的来说，Minio是一个灵活、可靠的分布式文件系统，适用于各种规模的存储需求。它的简单易用性和对S3 API的支持使得它成为一个受欢迎的选择。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值