Minio 文件对象存储 中间件

已于 2024-01-11 15:55:43 修改
阅读量1.3k 收藏 20
点赞数 20
文章标签： spring boot 中间件
于 2024-01-11 15:50:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57392053/article/details/135519623
版权
本文介绍了MinIO，一个开源的S3兼容对象存储服务器，其特点包括分布式部署、安全性、高可用性以及与SpringBoot的集成。文章详细讲解了MinIO的核心概念、安装方法、Docker部署、以及如何在SpringBoot应用中使用MinIOSDK进行文件存储和管理。
摘要由CSDN通过智能技术生成

基本概念

MinIO 是一个开源的对象存储服务器，它允许你使用 AWS S3 兼容的 API 存储和检索任意类型的数据。

对象存储： MinIO 提供了一个简单而强大的对象存储解决方案。你可以使用 MinIO 存储各种类型的文件、图片、视频、文档等。

S3 兼容性： MinIO 实现了与 Amazon S3 兼容的 API，因此你可以使用与 S3 相似的方式与 MinIO 进行交互。这意味着你可以使用支持 S3 的应用程序或工具（如AWS SDK）连接到 MinIO，并对存储在 MinIO 中的对象进行操作。

分布式部署：MinIO 支持分布式部署，可以通过添加更多的节点来扩展存储容量和性能。

安全性：MinIO 提供了许多安全功能，包括数据加密、访问控制和身份验证。

高可用性：通过使用分布式部署和故障转移机制，MinIO 可以提供高可用性，确保你的数据始终可访问。

首先需要先了解一下这个minio是干嘛的，在开发的时候对我们开发人员使用来说就是暴露Api接口供我们使用，按照指定的方式将文件直接上传即可，后面所有的事情都是minio去帮我们在做，例如对文件分块存储等。

当然，也可以适当的去了解一下大概得原理

存储原理：

他的存储原理也是分块存储，意思是会将一份文件存储到多个块，每个块的大小默认是64mb。下载的时候会拿到所有的块，组成一个完整的文件，如果文件小于64mb则是存储在一个块里面

从安全性角度来看，将文件分成多个块并存储在不同的位置，可以增加数据的冗余备份和容错能力。即使某个节点或块发生故障，仍然可以通过其他节点或块来恢复数据，确保数据的可靠性和持久性。同时，由于拿到部分块无法还原完整的文件，这种分块存储机制也增加了数据的安全性，防止未经授权的访问和泄露。

从性能角度来看，将文件切分成多个块，并行读取多个块可以提高数据的读取效率。多个线程或者并发请求可以同时读取不同的块，减少了读取的等待时间。此外，由于每个块的大小相对较小，可以更好地利用网络带宽和存储设备的性能，提高数据的传输速度和处理效率。

因此，MinIO 的分块存储机制既提升了数据的安全性，又提高了数据的读取性能，适应了现代大规模数据存储和处理的需求。

安装Minio（Docker安装）

不会Docker的话可以去查一下安装包的安装方法，别人的安装教程 Linux安装Minio

当然也可以直接使用Docker，因为就几个命令，也不难

Docker有了并且基本会用的，可以直接看拉取镜像和创建容器的那部分了

安装Docker

  • yum -y update
    用于更新操作系统中已安装软件包的命令
    具体来说，yum -y update 命令会检查您的操作系统中已安装软件包的最新版本，并将其升级到最新版本。这包括操作系统内核、系统工具、库文件、应用程序等。通过执行此命令，您可以获得最新的功能、安全性和性能改进，并修复已知的漏洞和错误。

  • 安装Docker所需的依赖项

    sudo yum install -y yum-utils device-mapper-persistent-data lvm2

  • 设置Docker存储库（可国内阿里云的镜像）

    sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

  • 安装Docker

    sudo yum install -y docker-ce docker-ce-cli containerd.io

  • 启动验证安装成功与否

    • 启动
      sudo systemctl start docker
    • 设置开机自启
      sudo systemctl enable docker
    • 验证
      sudo docker run hello-world
      在这里插入图片描述
      这样就是成功

  • 拉取Minio

    docker pull minio/minio

  • 启动容器

    创建数据卷用于挂载数据（因为启动的容器，要修改以及持久化的问题，所以需要挂载到我们熟悉的地方，例如修改配置文件需要进入容器内部，或者该容器产生的数据我们删除容器之后会找不到或消失）

    mkdir /usr/local/software/minio/data /usr/local/software/minio/config

    启动命令

    docker run --name minio -p 9000:9000 -p 9001:9001 -v /usr/local/software/minio/data/:/data -v /usr/local/software/minio/config/:/root/.minio -d --restart=always -e "MINIO_ACCESS_KEY=admin" -e "MINIO_SECRET_KEY=admin123" minio/minio server /data --console-address ":9000" --address ":9001"

    说明：--console-address ":9000"--address ":9001"分别表示控制台的端口和Minio服务的端口
    -e "MINIO_ACCESS_KEY=admin" 账号 -e "MINIO_SECRET_KEY=admin123" 密码

  • 验证是否成功
    打开控制台 ip + --console-address 的端口（9000）看到下面的页面就成功了，输入run命令中的账号密码即可
    在这里插入图片描述

术语

存储桶（Bucket）：MinIO 中的存储单元，类似于文件系统中的文件夹。存储桶用于组织和管理对象。

对象（Object）：存储在存储桶中的基本数据单元。对象可以是任何类型的文件，例如图片、视频、文档等。

区域（Region）：MinIO 的多区域部署方案中，指的是物理位置或数据中心，用于提供高可用性和容错性。

签名（Signature）：在 MinIO 客户端与服务器之间进行身份验证和请求的安全传输过程中使用的密钥。

策略（Policy）：用于定义访问控制规则的配置文件。策略决定了谁可以执行哪些操作以及对哪些资源具有权限。

生命周期（Lifecycle）：用于管理对象在特定时间点自动转换存储类别、删除或其他操作的规则。

版本控制（Versioning）：一项功能，允许在存储桶中保留对象的多个版本，以便进行版本控制和恢复。

分片上传（Multipart Upload）：将大型对象分割为较小的块进行并行上传，提高上传效率和可靠性。

这些术语和概念是 MinIO 中常用的，了解它们可以帮助你更好地理解和使用 MinIO 存储服务。

Spring Boot集成Minio

整合的环境是Spring Boot 3.x版本，jdk17，Minio 8.5.5版本的

  • 引入依赖
        <dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <version>8.5.5</version>
        </dependency>

  • Minio SDK 简述

    集成minio主要是通过minioclient实现的。
    在这里插入图片描述
    因此我们需要先创建Minio Client对象，是的你没听错，需要手动创建，他不像Redis那种有Spring starter的

    在application.yml里面配置minio服务器地址
    在这里插入图片描述
    创建minioconfig，注入minioclient的bean到Spring中。

    package com.example.household_supplies.config;
import io.minio.MinioClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MinIOConfig {

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

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

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

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

  • MinioClient 使用

    • 常见内置方法说明

      	public StatObjectResponse statObject(StatObjectArgs args) // 从Minio获取对象的元数据信息

	public GetObjectResponse getObject(GetObjectArgs args) // 从Minio获取文件对象的文件流
	
	public void downloadObject(DownloadObjectArgs args) // 从Minio下载到指定文件

	public ObjectWriteResponse copyObject(CopyObjectArgs args) // 在Minio的不同的bucket之间copy数据

	public String getPresignedObjectUrl(GetPresignedObjectUrlArgs args) // 生成临时的访问url

	public void removeObject(RemoveObjectArgs args) // 从Minio中删除文件

	public ObjectWriteResponse putObject(PutObjectArgs args) // 上传到Minio文件中

	public boolean bucketExists(BucketExistsArgs args) // 检查桶是否存在

	public List<Bucket> listBuckets(ListBucketsArgs args) // 获取所有存储桶

	public void makeBucket(MakeBucketArgs args) // 创建指定的桶

    • 使用（写成一个工具类了）

      package com.example.household_supplies.util;

import com.example.household_supplies.exception.BizAssertUtils;
import io.minio.*;
import io.minio.errors.*;
import io.minio.http.Method;
import io.minio.messages.Bucket;
import io.minio.messages.Source;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * @Classname MinioStroage
 * @Description TODO
 * @Version 1.0.0
 * @Created by wlh12
 */
@Repository
@Slf4j
public class MinioStroage {

    @Autowired
    private MinioClient minioClient;

    /**
     * 上传
     *
     * @param file
     * @param bucket
     * @return
     */
    public String upload(MultipartFile file, String bucket) {
        String fileName = buildFileName(file.getOriginalFilename());
        try (InputStream inputStream = file.getInputStream()) {
            if (!bucketExists(bucket)) {
                createBucket(bucket);
            }
            PutObjectArgs putObjectArgs = PutObjectArgs
                    .builder()
                    .bucket(bucket)
                    .object(fileName)
                    .stream(inputStream, inputStream.available(), -1)
                    .build();
            minioClient.putObject(putObjectArgs);
        } catch (Exception e) {
            log.error("minio上传失败：", e);
            throw new RuntimeException(e);
        }
        return fileName;
    }

    /**
     * 批量上传
     *
     * @param files
     * @param bucket
     * @return
     */
    public String[] upload(MultipartFile[] files, String bucket) {
        String[] strings = new String[files.length];
        int i = 0;
        for (MultipartFile file : files) {
            String res = upload(file, bucket);
            strings[i++] = res;
        }
        return strings;
    }

    /**
     * 批量下载
     *
     * @param fileNames
     * @param bucket
     * @return
     */
    public List<byte[]> download(String[] fileNames, String bucket) {
        List<byte[]> list = new ArrayList<>();
        for (String fileName : fileNames) {
            byte[] download = download(fileName, bucket);
            list.add(download);
        }
        return list;
    }

    /**
     * 批量删除
     *
     * @param fileNames
     * @param bucket
     */
    public void delete(String[] fileNames, String bucket) {
        for (String fileName : fileNames) {
            delete(fileName, bucket);
        }
    }

    /**
     * 下载
     *
     * @param fileName
     * @param bucket
     * @return
     */
    public byte[] download(String fileName, String bucket) {
        BizAssertUtils.isTrue(bucketExists(bucket), "该文件不存在！");
        GetObjectArgs getObjectArgs = GetObjectArgs.builder()
                .bucket(bucket)
                .object(fileName)
                .build();
        try (InputStream inputStream = minioClient.getObject(getObjectArgs)) {
            return inputStream.readAllBytes();
        } catch (Exception e) {
            log.error("minio获取文件失败：", e);
            throw new RuntimeException(e);
        }
    }

    /**
     * 将指定文件下载保存到本机file
     *
     * @param filename
     * @param bucket
     * @param file
     */
    public void saveLocal(String filename, String bucket, File file) {
        try {
            DownloadObjectArgs downloadObjectArgs = DownloadObjectArgs.builder()
                    .bucket(bucket)
                    .object(filename)
                    .filename(file.getPath())
                    .build();

            minioClient.downloadObject(downloadObjectArgs);
        } catch (Exception e) {
            log.error("从Minio保存本地失败：", e);
            throw new RuntimeException(e);
        }
    }

    /**
     * 删除文件
     *
     * @param fileName
     * @param bucket
     */
    public void delete(String fileName, String bucket) {
        BizAssertUtils.isTrue(bucketExists(bucket), "该文件不存在！");
        RemoveObjectArgs removeObjectArgs = RemoveObjectArgs.builder()
                .bucket(bucket)
                .object(fileName)
                .build();
        try {
            minioClient.removeObject(removeObjectArgs);
        } catch (Exception e) {
            log.error("minio删除文件失败：", e);
            throw new RuntimeException(e);
        }
    }


    /**
     * 获取文件对象的信息（不下载文件），例如标签，大小，最后修改时间，保留时间信息等等。
     *
     * @param filename
     * @param bucket
     * @return
     */
    public StatObjectResponse getStatObjectInfo(String filename, String bucket) {
        try {
            StatObjectArgs statObjectArgs = StatObjectArgs.builder()
                    .bucket(bucket)
                    .object(filename)
                    .build();

            return minioClient.statObject(statObjectArgs);
        } catch (Exception e) {
            log.error("minio获取文件信息失败：", e);
            throw new RuntimeException(e);
        }
    }


    /**
     * 将指定文件从srcBucket复制到tarBucket中
     * @param filename
     * @param srcBucket
     * @param tarBucket
     */
    public void copyToBucket(String filename, String srcBucket, String tarBucket) {

        try {
            boolean b = bucketExists(srcBucket);
            BizAssertUtils.isTrue(b, "srcBucket 不存在");
            b = bucketExists(tarBucket);
            if (!b) {
                createBucket(tarBucket);
            }
            CopyObjectArgs copyObjectArgs = CopyObjectArgs.builder()
                    .bucket(tarBucket)
                    .object(filename)
                    .source(
                            CopySource.builder()
                                    .bucket(srcBucket)
                                    .object(filename)
                                    .build()
                    )
                    .build();
            minioClient.copyObject(copyObjectArgs);
        } catch (Exception e) {
            log.error("minio copy失败：", e);
            throw new RuntimeException(e);
        }
    }

    /**
     * 获取该文件的预览地址
     * @param filename
     * @param bucket
     * @return
     */
    public String previewUrl(String filename, String bucket) {
        try {
            GetPresignedObjectUrlArgs getPresignedObjectUrlArgs = GetPresignedObjectUrlArgs.builder()
                    .bucket(bucket)
                    .object(filename)
                    .method(Method.GET) // 设置预览的请求方法
                    .build();
            return minioClient.getPresignedObjectUrl(getPresignedObjectUrlArgs);
        } catch (Exception e) {
            log.error("minio获取预览url失败：", e);
            throw new RuntimeException(e);
        }
    }


    /**
     * 检查bucket桶是否存在
     *
     * @param bucket
     * @return
     */
    public boolean bucketExists(String bucket) {
        BucketExistsArgs existsArgs = BucketExistsArgs
                .builder()
                .bucket(bucket)
                .build();
        try {
            return minioClient.bucketExists(existsArgs);
        } catch (Exception e) {
            log.error("检查bucket失败：", e);
            throw new RuntimeException(e);
        }
    }

    /**
     * 创建bucket桶
     *
     * @param bucket
     */
    public void createBucket(String bucket) {
        MakeBucketArgs makeBucketArgs = MakeBucketArgs
                .builder()
                .bucket(bucket)
                .build();
        try {
            minioClient.makeBucket(makeBucketArgs);
        } catch (Exception e) {
            log.error("创建bucket失败：", e);
            throw new RuntimeException(e);
        }
    }

    /**
     * 获取当前Minio服务器的所有存储桶
     *
     * @return
     */
    public List<Bucket> getBucketList() {
        try {
            return minioClient.listBuckets();
        } catch (ErrorResponseException | InsufficientDataException | InternalException | InvalidKeyException |
                 InvalidResponseException | IOException | NoSuchAlgorithmException | ServerException |
                 XmlParserException e) {
            log.error("获取bucket列表失败：", e);
            throw new RuntimeException(e);
        }
    }


    /**
     * 获取当前Minio服务器的所有存储桶
     *
     * @param queryParam 额外的查询参数
     * @param headers    额外的请求头信息
     * @return
     */
    public List<Bucket> getBucketList(Map<String, String> queryParam, Map<String, String> headers) {
        try {
            ListBucketsArgs.Builder builder = ListBucketsArgs.builder();
            if (queryParam != null && !queryParam.isEmpty()) {
                builder.extraQueryParams(queryParam);
            }

            if (headers != null && !headers.isEmpty()) {
                builder.extraHeaders(headers);
            }
            ListBucketsArgs listBucketsArgs = builder.build();
            return minioClient.listBuckets(listBucketsArgs);
        } catch (ErrorResponseException | InsufficientDataException | InternalException | InvalidKeyException |
                 InvalidResponseException | IOException | NoSuchAlgorithmException | ServerException |
                 XmlParserException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 用于生成文件名称
     *
     * @param fileName
     * @return
     */
    public String buildFileName(String fileName) {
        int index = fileName.lastIndexOf(".");
        String suffix = fileName.substring(index);

        return System.currentTimeMillis() + CodeUtil.createNumberCode(3) + suffix;
    }
}

到了这，Minio的基本使用就结束了，更多的可以去看MinioClient里面的示例

恋旧的人迟早会溺死在回忆中
关注
  • 20
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于Linux系统的minio分布式对象存储二进制文件包及启动脚本
12-02
MinIO 是一款基于Go语言发开的高性能、分布式的对象存储系统。客户端支持Java,Net,Python,Javacript, Golang语言。
Springboot通过MinIO进行文件操作代码
09-27
Springboot通过MinIO进行文件上传、文件下载、删除文件的功能代码，以及图片视频文件的预览功能代码
深入探索MinIO：高性能的开源对象存储服务器
最新发布
shiranyyds的博客
04-30 1888
MinIO是一个高性能的开源对象存储服务器，它兼容Amazon S3云存储服务接口，并采用了Amazon S3的API（包括access control和buckets）。MinIO可以看作是一个分布式对象存储系统，它将数据分散存储在一个或多个集群中，每个集群由多个节点组成。MinIO支持多种存储后端，包括本地文件系统、分布式文件系统和云存储服务等。
SpringBoot2 整合MinIO中间件，实现文件便捷管理.docx
07-04
MinIO使用按对象的嵌入式擦除编码保护数据，该编码以汇编代码编写，可提供最高的性能。MinIO使用Reed-Solomon代码将对象划分为n/2个数据和n / 2个奇偶校验块-尽管可以将它们配置为任何所需的冗余级别。 这意味着在12个驱动器设置中，将一个对象分片为6个数据和6个奇偶校验块。即使丢失了多达5个(（n/2）–1)个驱动器（无论是奇偶校验还是数据），仍然可以从其余驱动器可靠地重建数据。MinIO的实现可确保即使丢失或无法使用多个设备，也可以读取对象或写入新对象。最后，MinIO的擦除代码位于对象级别，并且可以一次修复一个对象。
Java分布式文件对象存储Minio框架并发上传、下载、合并、删除等操作示例Demo完整版
08-01
Java分布式文件对象存储Minio框架并发上传、下载、合并、删除等操作示例Demo完整版，可用于生产环境开发。
minio 文件服务器
07-10
minio 文件服务器环境搭建/以及示例代码，方便搭建文件服务器，代码包含传统的本地保存、minio保存、s3保存等示例代码。
Minio是什么中间件
岛田悠米
08-20 1539
Minio 是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几kb到最大5T不等。 Minio是一个非常轻量的服务,可以很简单的和其他应用的结合，类似 NodeJS, Redis 或者 MySQL。 Minio不仅提供了服务器、Web访问、客户端，还提供了Docker安装，各种语言的SDK、实例、实战秘籍等等，支持分布式部署。
SpringBoot2 整合MinIO中间件，实现文件便捷管理
【积累】，是一个长期持续的过程。
07-27 2291
MinIO是一个开源的对象存储服务。适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几kb到最大5T不等。MinIO是一个非常轻量的服务,可以很简单的和其他应用的结合，类似NodeJS,Redis或者MySQL。...
中间件——MinIO：部署篇
qq_42117917的博客
07-14 7628
MinIO的集群部署篇
中间件(18) : minio
Lxinccode的博客
05-18 180
参考 : MinIO Java接口实现创建桶,设置桶策略_minio 创建bucket_Meta.Qing的博客-CSDN博客 Java上传文件到minio_javac-coder的博客-CSDN博客 minio配置 minio管理
你可需要的对象存储中间件《Minio使用》
我是香菜
12-05 1816
minio 使用
开源对象存储系统OpenIO.zip
07-17
OpenIO 是一个开源的对象存储解决方案，用于大规模面向性能要求的低延迟的存储架构，特别为体积小量大的存储对象。发布容易，添加存储设备无需对数据进行重新分配。 标签：OpenIO
minio文件存储服务
08-16
新建一个目录存放minio文件，如 D:\minioData，CMD进入刚刚下载的minio.exe所在目录，直接在cmd下运行:minio.exe server D:\minioData 启动成功以后如记住显示的access Key和Secret Key (默认全是minioadmin) ...
【愚公系列】2022年05月 .NET架构班 071-分布式中间件 Minio的使用
热门推荐
时光隧道
05-27 1万+
文章目录一、MinIO的基本概念二、MinIO的基本使用1.前提准备2.具体使用2.1 启动Minio2.2 上传单个文件2.3 批量上传文件2.4 下载单个文件2.5 批量下载文件 一、MinIO的基本概念 Minio是一个基于Apache License v2.0开源的分布式对象存储服务。它兼容亚马逊S3云存储服务接口，异常符合于存储大容量非构造化的数据，比如图片、视频、日记文献、备份数据和容器/杜撰机镜像等，而一个工具文献能够是任性巨细，从几kb到最大5T不等。且Minio十足笨重，可与使用顺序绳捆
java中几种对象存储（文件存储）中间件的介绍
JAVA领域优质创作者，基于分片网络查询方法专利发明者。
03-11 1863
在博主得到系统中使用的对象存储主要有OSS（阿里云的对象存储） COS（腾讯云的对象存储）OBS（华为云的对象存储）还有就是MinIO 这些玩意。其实这种东西大差不差，几乎实现方式都是一样，存储模式大同小异。下面介绍几种存储模式在springBoot中的使用。
分布式文件存储系统minio
Hubery_sky的博客
11-23 1145
它兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几kb到最大5T不等。：非结构化数据是数据结构不规则或不完整，没有预定义的数据模型，不方便用数据库二维逻辑表来表现的数据。：也称作行数据，是由二维表结构来逻辑表达和实现的数据，严格地遵循数据格式与长度规范，主要通过关系型数据库进行存储和管理。：高度组织化和格式化，可以用二维表结构来逻辑表达和实现的数据。：文本，图像，图形，音频，视频等。
分布式文件系统使用——MinIO
weixin_45565886的博客
02-15 3201
分布式文件系统使用——MinIO
Minio: 文件类型数据存储
AI数据工厂
04-07 1054
另一种方式是，将这些文件以对象的方式存储到云服务器上，这样既没有丢失风险，也不必担心本地磁盘被撑爆，同时也方便给他人分享数据。我们这里提供了一种客户端实现，可以将文件或者对象上传到指定的服务器路径上，并根据指定的“bucket”进行查询与自动创建。在这里，我们利用了一个叫做Minio的对象存储方式，它可以提供安全、可靠、边界的存储及分享方式。:param bucket_names: 桶名称，用于存放数据的根目录。支持两种上传方式：文件形式、对象形式。:param secret_key: 密码。
minIO存储的文件时是连续的吗
04-14
？关于MinIO存储的文件是否是连续的，可以这样理解：MinIO是一款开源的分布式对象存储软件，它是基于Amazon S3协议构建的，可以提供高可用性、冗余备份、水平扩展的存储服务。在MinIO中，所有文件都是以对象的形式进行存储，每个对象都包含了对象的元数据和数据内容，这些对象之间并没有直接的联系，因此在物理上可以是存储在不同的磁盘或节点上，也可以是部分地存储在内存或磁盘缓存中。因此，虽然MinIO支持断点续传和并行上传下载等高级功能，但并不一定保证存储文件的连续性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值