MinIO使用记录

minio · 浏览次数 : 23

小编点评

本文主要介绍了MinIO，一款高性能、分布式对象存储解决方案。MinIO具有去中心化架构、多租户支持、纠删编码、高性能并发处理等特点，适用于大规模的非结构化数据存储和检索。文章还详细描述了MinIO的架构、技术栈、开源与跨平台特性以及集群部署等方面的内容。 1. **MinIO简介**： - MinIO是一款高性能、分布式对象存储服务器。 - 设计用于大规模环境中存储和检索非结构化数据集。 - 完全开源，遵循Apache License v2.0，兼容Amazon S3 API。 - 支持多租户，保证数据安全和隔离性。 - 提供多种数据持久性和一致性保障机制。 2. **MinIO架构与技术**： - 采用去中心化的无共享架构，提高系统性能和可靠性。 - 统一命名空间，简化用户操作。 - 支持水平扩展，易于添加新节点。 - 使用纠删编码技术，提高数据可靠性和容错性。 - 高并发处理能力，满足大规模数据处理需求。 3. **开源与跨平台**： - 开源许可证为Apache License v2.0。 - 支持在多种操作系统上运行，如Linux、Windows和macOS。 - 提供单节点部署和集群部署两种模式。 4. **集群部署**： - 集群由多个节点组成，每个节点都是独立的MinIO服务器实例。 - 支持动态扩展和缩放，以适应不同的存储需求。 - 提供了负载均衡功能，确保请求均匀分布到各个节点。 总的来说，MinIO是一个功能强大、灵活可扩展的对象存储解决方案，适合那些需要在大规模环境中存储和管理非结构化数据的组织。

正文

探索MinIO：高性能、分布式对象存储解决方案

注：本文除代码外多数为AI生成

最近因为有项目需要换成Amazon S3的云存储，所以把之前做过的minio部分做一个记录，后面也会把基于这版改造的S3方法发出来记录。

MinIO简介

MinIO是一款高性能、分布式对象存储服务器，设计用于在大规模环境中存储和检索非结构化数据集，如图像、视频和日志文件。它完全开源，遵循Apache License v2.0，并且与Amazon S3 API兼容，这使得从现有的S3环境迁移变得简单。MinIO支持多租户，确保了数据的安全性和隔离性，同时提供了多种数据持久性和一致性保障机制。由于其出色的性能特性，如高吞吐量和低延迟，MinIO成为了众多企业和组织在构建现代云基础设施时的首选对象存储解决方案。

MinIO架构与技术

去中心化架构
  • 无共享架构：MinIO采用了一种去中心化的无共享架构，这意味着没有单一的瓶颈点或中心化的元数据服务器。数据和元数据分布在集群内的所有节点上，提高了系统的整体性能和可靠性。
  • 统一命名空间：尽管数据分布在多个节点上，但MinIO对外提供了一个统一的命名空间，用户无需关心数据的具体位置。
分布式特性
  • 水平扩展：MinIO可以很容易地通过添加更多的节点来水平扩展，每个节点都是对等的，可以独立运行和存储数据。
  • 纠删编码：为了提高数据的可靠性和容错性，MinIO使用纠删编码技术（Erasure Coding）来存储数据。这允许数据在多个节点上以冗余的形式存在，即使部分节点发生故障，数据仍然可读。
高性能
  • 并发处理：MinIO的设计考虑到了高并发性，能够同时处理大量的读写请求，提供低延迟和高吞吐量。
  • 网络优化：MinIO通过高效的网络协议和数据传输优化，确保数据在网络中的快速流动。
兼容性
  • S3 API兼容：MinIO完全兼容Amazon S3 API，这使得它可以无缝地与许多已有的应用程序和服务集成，降低了迁移成本。
安全性
  • 加密：MinIO支持静态数据加密，确保数据在存储期间的安全。
  • 访问控制：通过IAM（Identity and Access Management）策略，MinIO提供了细粒度的访问控制，保护数据不被未授权访问。
开源与跨平台
  • 开源许可证：MinIO遵循Apache License v2.0开源协议，允许自由使用、修改和分发。
  • 跨平台：MinIO可以在多种操作系统上运行，包括Linux、Windows和macOS，增强了其部署灵活性。
集群部署
  • 多节点集群：MinIO可以部署为一个集群，其中包含多个节点，这些节点共同维护数据的一致性和可用性。
  • 负载均衡：在集群中，可以通过DNS轮询或负载均衡器来分配请求到不同的节点，确保负载均匀分布。
技术栈
  • Go语言：MinIO使用Go语言编写，这提供了良好的性能和简洁的代码基础。

Minio的安装部署

单节点部署

  • 参考https://www.cnblogs.com/ComfortableM/p/17384523.html

集群部署概念

  1. 节点：MinIO集群由多个节点组成，每个节点都是一个独立运行的MinIO服务器实例。
  2. 纠删编码：为了实现数据冗余和容错，MinIO使用纠删编码（Erasure Coding）。这种技术允许数据被分割成多个片段，并且每个片段都有额外的校验信息。如果集群中有节点失效，数据仍然可以从剩余的节点中重构出来。
  3. 数据分布：数据均匀分布在所有节点上，以达到负载均衡和最大化使用所有存储资源的目的。

部署步骤

  1. 环境准备：
    • 确保有足够的物理服务器或虚拟机。
    • 准备好足够的磁盘空间，每台服务器可以使用单个磁盘或多个磁盘。
    • 配置网络，确保所有节点之间可以互相通信。
  2. 软件安装：
    • 在每台服务器上安装MinIO软件。可以通过二进制包、Docker容器或软件包管理系统完成。
    • 配置MinIO服务器，指定数据存储目录和集群相关的配置。
  3. 启动MinIO服务：
    • 在每个节点上启动MinIO服务，使用集群模式的启动参数。
    • 指定集群中的其他节点，以便它们可以相互发现并形成集群。
  4. 验证集群状态：
    • 使用MinIO的管理命令或Web UI检查集群状态，确认所有节点是否已成功加入集群。
    • 测试读写操作，确保数据可以正确地在集群中分布和访问。
  5. 监控和维护：
    • 设置监控，持续监控集群的健康状况和性能指标。
    • 定期进行维护，如数据平衡、硬件升级或替换故障节点。

关键考虑因素

  • 节点数量：集群至少需要4个节点来实现数据的冗余和分布。通常，节点数量越多，数据的可用性和性能就越好。
  • 数据冗余：根据纠删编码策略，集群可以容忍一定数量的节点故障而不会丢失数据。
  • 网络配置：确保网络稳定和高速，因为集群中的节点需要频繁地相互通信。
  • 故障恢复：设计故障恢复计划，包括节点替换、数据重建和灾难恢复策略。
  • 性能调优：根据实际工作负载，可能需要调整网络带宽、磁盘I/O或其他系统参数来优化性能。

扩展和缩放

  • 扩展：通过添加更多节点可以轻松扩展MinIO集群的容量和性能。
  • 缩放：移除节点时需要小心，确保数据冗余不会降低到不可接受的水平。

注意事项

  • 使用hosts文件或DNS服务来解决集群内部的域名或IP地址，避免直接在配置文件中硬编码IP地址，这有助于在节点变化时更容易地维护集群。
  • 在部署多节点多磁盘的集群时，确保遵循最佳实践，如避免在同一服务器上使用过多的磁盘，以防服务器故障导致大量数据不可用。

下面为例：

  • 节点启动方式，每个节点都需要启动
export MINIO_ACCESS_KEY=admin
export MINIO_SECRET_KEY=minioadmin
#console-address参数可设可不设
./minio server --address ":9001" --console-address ":9011" 
"http://ipA:9001/arcfile/minioData/data" 
"http://ipB:9001/arcfile/minioData/data"
"http://ipC:9001/arcfile/minioData/data"
"http://ipD:9001/arcfile/minioData/data" >/arcfile/minioData/logs/start.txt 2>&1 &
  • 如果要用来测试，可以一个服务器部署四个节点。以上面为例修改端口启动，或者参考下面的启动脚本
RUNNING_USER=root
MINIO_HOME=/opt/minio
MINIO_HOST=192.168.222.10
#accesskey and secretkey
ACCESS_KEY=admin 
SECRET_KEY=minioadmin

for i in {01..04}; do
    START_CMD="MINIO_ACCESS_KEY=${ACCESS_KEY} MINIO_SECRET_KEY=${SECRET_KEY} nohup ${MINIO_HOME}/minio  server --address "${MINIO_HOST}:90${i}" http://${MINIO_HOST}:9001/opt/min-data1 http://${MINIO_HOST}:9002/opt/min-data2 http://${MINIO_HOST}:9003/opt/min-data3 http://${MINIO_HOST}:9004/opt/min-data4 > ${MINIO_HOME}/minio-90${i}.log 2>&1 &"
    su - ${RUNNING_USER} -c "${START_CMD}"
done

集成Spring boot项目

添加依赖
        <dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <version>8.3.3</version>
        </dependency>

        <!--如果出现okhttp依赖冲突，添加下面依赖-->
<!--        <dependency>-->
<!--            <groupId>com.squareup.okhttp3</groupId>-->
<!--            <artifactId>okhttp</artifactId>-->
<!--            <version>4.9.0</version>-->
<!--        </dependency>-->
创建配置类
import io.minio.MinioClient;
import io.minio.errors.*;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.logging.Logger;

@Configuration
public class MinioClientConfig {

    private final Logger log = Logger.getLogger(this.getClass().getName());

    @Value("${config.minio.url}")
    private String MINIO_URL;
    @Value("${config.minio.accessKey}")
    private String MINIO_ACCESS_KEY;
    @Value("${config.minio.secretKey}")
    private String MINIO_SECRET_KEY;

    @Bean
    public MinioClient getMinioClient() {
        if (MINIO_URL.length() == 0 || MINIO_URL == null) {
            throw new IllegalArgumentException("\n请正确配置Minio服务器的 URL 连接参数");
        }
        if (MINIO_ACCESS_KEY.length() == 0 || MINIO_ACCESS_KEY == null) {
            throw new IllegalArgumentException("\n请正确配置Minio服务器的 ACCESS_KEY 连接参数");
        }
        if (MINIO_SECRET_KEY.length() == 0 || MINIO_SECRET_KEY == null) {
            throw new IllegalArgumentException("\n请正确配置Minio服务器的 SECRET_KEY 连接参数");
        }
        MinioClient minioClient = MinioClient.builder()
                .endpoint(MINIO_URL)
                .credentials(MINIO_ACCESS_KEY, MINIO_SECRET_KEY)
                .build();
        try {
            minioClient.listBuckets();
        } catch (ErrorResponseException e) {
            e.printStackTrace();
            throw new RuntimeException("\nMinio服务器连接异常\n请检查所配置的Minio连接信息Access-key和Secret-Key是否正确");
        } catch (InsufficientDataException e) {
            e.printStackTrace();
        } catch (InternalException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (InvalidResponseException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
            throw new RuntimeException("\nMinio服务器连接异常\n请检查Minio服务器是否已开启或所配置的Minio_url连接信息是否正确");
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (ServerException e) {
            e.printStackTrace();
        } catch (XmlParserException e) {
            e.printStackTrace();
        }
        log.info("Minio服务器连接成功，URL = " + MINIO_URL);
        return minioClient;
    }
}

基本操作介绍

  • 创建桶
public boolean createBucket(String bucketName) throws RuntimeException {
minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
}
  • 配置桶权限为公开
public void BucketAccessPublic(String bucketName) {
String config = "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]},\"Action\":[\"s3:ListBucketMultipartUploads\",\"s3:GetBucketLocation\",\"s3:ListBucket\"],\"Resource\":[\"arn:aws:s3:::" + bucketName + "\"]},{\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]},\"Action\":[\"s3:ListMultipartUploadParts\",\"s3:PutObject\",\"s3:AbortMultipartUpload\",\"s3:DeleteObject\",\"s3:GetObject\"],\"Resource\":[\"arn:aws:s3:::" + bucketName + "/*\"]}]}";
	minioClient.setBucketPolicy(SetBucketPolicyArgs.builder().bucket(bucketName).config(config).build();
}
  • 上传对象

uploadObject()

//上传本地文件
public boolean uploadObject(String bucketName, String targetObject, String sourcePath) {
        try {
            minioClient.uploadObject(UploadObjectArgs.builder()
                    .bucket(bucketName)
                    .object(targetObject)
                    .filename(sourcePath)
                    .build());
        } catch (ErrorResponseException e) {
            e.printStackTrace();
            return false;
        } catch (InsufficientDataException e) {
            e.printStackTrace();
        } catch (InternalException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (InvalidResponseException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (ServerException e) {
            e.printStackTrace();
        } catch (XmlParserException e) {
            e.printStackTrace();
        }
        return true;
    }

putObject()

public boolean putObject(String bucketName, String object, InputStream inputStream) {
        try {
            minioClient.putObject(PutObjectArgs.builder()
                    .bucket(bucketName)
                    .object(object)
                    //.contentType("application/pdf")不设置的话默认是"application/stream"，这就是为什么某些文件上传上去无法直接预览的问题
                    .stream(inputStream, -1, 10485760)
                    //.tags(tags)上传可以直接携带标签
                    .build());
        } catch (ErrorResponseException e) {
            e.printStackTrace();
            return false;
        } catch (InsufficientDataException e) {
            e.printStackTrace();
        } catch (InternalException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (InvalidResponseException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (ServerException e) {
            e.printStackTrace();
        } catch (XmlParserException e) {
            e.printStackTrace();
        }
        return true;
    }
  • 下载对象
    public GetObjectResponse getObject(String bucketName, String object) {
        GetObjectResponse object1 = null;//这个对象是集成了InputStream的FilterInputStream类，所以是可以直接用流来处理文件的
        try {
            object1 = minioClient.getObject(GetObjectArgs.builder()
                    .bucket(bucketName)
                    .object(object)
                    .build());
        } catch (ErrorResponseException e) {
            e.printStackTrace();
        } catch (InsufficientDataException e) {
            e.printStackTrace();
        } catch (InternalException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (InvalidResponseException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (ServerException e) {
            e.printStackTrace();
        } catch (XmlParserException e) {
            e.printStackTrace();
        }
        return object1;
    }
  • 获取对象预签名Url
/**
 * 生成预签名URL，允许外部在限定时间内访问指定的MinIO对象。
 * 
 * @param bucketName 存储桶名称
 * @param object 对象名称
 * @param expire 过期时间，单位是分钟
 * @param map 用于自定义HTTP响应头的映射，例如设置Content-Type
 * @return 返回预签名的URL，可以用于直接访问对象
 */
public String presignedURLofObject(String bucketName, String object, int expire, Map<String, String> map) {
    // 设置响应的内容类型为application/json
    map.put("response-content-type", "application/json");
    
    // 初始化预签名URL字符串
    String presignedObjectUrl = "";
    
    // 尝试获取预签名的URL
    try {
        // 构建获取预签名URL的参数
        presignedObjectUrl = minioClient.getPresignedObjectUrl(
            GetPresignedObjectUrlArgs.builder()
                .bucket(bucketName)          // 设置存储桶名称
                .object(object)              // 设置对象名称
                .method(Method.GET)          // 设置HTTP方法为GET
                .expiry(expire, TimeUnit.MINUTES) // 设置过期时间为expire分钟后
                //.extraQueryParams(map)     // 注释掉的代码，用于设置额外的查询参数
                .build()                     // 构建参数对象
        );
    } catch (ErrorResponseException e) {
        // 处理错误响应异常
        e.printStackTrace();
    } catch (InsufficientDataException e) {
        // 数据不足异常
        e.printStackTrace();
    } catch (InternalException e) {
        // MinIO内部异常
        e.printStackTrace();
    } catch (InvalidKeyException e) {
        // 无效的访问密钥异常
        e.printStackTrace();
    } catch (InvalidResponseException e) {
        // 无效的响应异常
        e.printStackTrace();
    } catch (IOException e) {
        // 输入输出异常
        e.printStackTrace();
    } catch (NoSuchAlgorithmException e) {
        // 不存在算法异常
        e.printStackTrace();
    } catch (XmlParserException e) {
        // XML解析异常
        e.printStackTrace();
    } catch (ServerException e) {
        // 服务器异常
        e.printStackTrace();
    }
    // 返回预签名的URL
    return presignedObjectUrl;
}

部分方法集

MinioService

import io.minio.ComposeSource;
import io.minio.GetObjectResponse;
import io.minio.Result;
import io.minio.StatObjectResponse;
import io.minio.messages.Bucket;
import io.minio.messages.Item;
import org.springframework.stereotype.Service;

import java.io.InputStream;
import java.util.List;
import java.util.Map;

/**
 * MinioService接口，定义了与MinIO对象存储系统交互的方法集。
 */
@Service
public interface MinioService {

    /**
     * 检查指定的存储桶是否存在。
     *
     * @param bucketName 存储桶名称
     * @return 如果存储桶存在则返回true，否则返回false。
     */
    boolean ifExistsBucket(String bucketName);

    /**
     * 创建一个新的存储桶。
     *
     * @param bucketName 要创建的存储桶名称
     * @throws RuntimeException 如果创建失败抛出运行时异常
     * @return 如果创建成功则返回true，否则返回false。
     */
    boolean createBucket(String bucketName) throws RuntimeException;

    /**
     * 删除指定的存储桶。
     *
     * @param bucketName 要删除的存储桶名称
     * @return 如果删除成功则返回true，否则返回false。
     */
    boolean removeBucket(String bucketName);

    /**
     * 列出所有已存在的存储桶。
     *
     * @return 包含所有存储桶信息的列表。
     */
    List<Bucket> alreadyExistBuckets();

    /**
     * 列出指定存储桶中的对象。
     *
     * @param bucketName 要列出对象的存储桶名称
     * @param predir 可选前缀，用于过滤对象名
     * @param recursive 是否递归列出子目录的对象
     * @return 包含匹配条件的对象列表。
     */
    List<Result<Item>> listObjects(String bucketName, String predir, boolean recursive);

    /**
     * 列出指定存储桶中的对象，用于组成对象操作。
     *
     * @param bucketName 要列出对象的存储桶名称
     * @param predir 可选前缀，用于过滤对象名
     * @return 包含对象信息的List<ComposeSource>对象列表。
     */
    List<ComposeSource> listObjects(String bucketName, String predir);

    /**
     * 复制一个对象到另一个位置。
     *
     * @param pastBucket 原始存储桶名称
     * @param pastObject 原始对象名称
     * @param newBucket 目标存储桶名称
     * @param newObject 目标对象名称
     * @return 如果复制成功则返回true，否则返回false。
     */
    boolean copyObject(String pastBucket, String pastObject, String newBucket, String newObject);

    /**
     * 下载存储桶中的对象到本地文件系统。
     *
     * @param bucketName 存储桶名称
     * @param objectName 对象名称
     * @param targetPath 目标文件路径
     * @return 如果下载成功则返回true，否则返回false。
     */
    boolean downObject(String bucketName, String objectName, String targetPath);

    /**
     * 生成一个预签名的URL，允许外部访问指定的对象。
     *
     * @param bucketName 存储桶名称
     * @param object 对象名称
     * @param expire URL的有效期（分钟）
     * @return 预签名的URL。
     */
    String presignedURLofObject(String bucketName, String object, int expire);

    /**
     * 生成一个预签名的URL，允许外部访问指定的对象，并自定义HTTP头部。
     *
     * @param bucketName 存储桶名称
     * @param object 对象名称
     * @param expire URL的有效期（分钟）
     * @param map 自定义的HTTP头部信息
     * @return 预签名的URL。
     */
    String presignedURLofObject(String bucketName, String object, int expire, Map<String, String> map);

    /**
     * 删除存储桶中的对象。
     *
     * @param bucketName 存储桶名称
     * @param object 对象名称
     * @return 如果删除成功则返回true，否则返回false。
     */
    boolean deleteObject(String bucketName, String object);

    /**
     * 上传本地文件到存储桶。
     *
     * @param bucketName 存储桶名称
     * @param targetObject 目标对象名称
     * @param sourcePath 本地文件路径
     * @return 如果上传成功则返回true，否则返回false。
     */
    boolean uploadObject(String bucketName, String targetObject, String sourcePath);

    /**
     * 从InputStream上传数据到存储桶。
     *
     * @param bucketName 存储桶名称
     * @param object 对象名称
     * @param inputStream 数据流
     * @return 如果上传成功则返回true，否则返回false。
     */
    boolean putObject(String bucketName, String object, InputStream inputStream);

    /**
     * 从InputStream上传数据到存储桶，并附带标签。
     *
     * @param bucketName 存储桶名称
     * @param object 对象名称
     * @param inputStream 数据流
     * @param tags 对象的标签集合
     * @return 如果上传成功则返回true，否则返回false。
     */
    boolean putObject(String bucketName, String object, InputStream inputStream, Map<String, String> tags);

    /**
     * 获取存储桶中的对象信息。
     *
     * @param bucketName 存储桶名称
     * @param object 对象名称
     * @return 对象的响应信息。
     */
    GetObjectResponse getObject(String bucketName, String object);

    /**
     * 检查存储桶中是否包含指定文件。
     *
     * @param bucketName 存储桶名称
     * @param filename 文件名称
     * @param recursive 是否递归查找
     * @return 如果文件存在则返回true，否则返回false。
     */
    boolean fileifexist(String bucketName, String filename, boolean recursive);

    /**
     * 获取对象的元数据标签。
     *
     * @param bucketName 存储桶名称
     * @param object 对象名称
     * @return 对象的元数据标签集合。
     */
    Map<String, String> getTags(String bucketName, String object);

    /**
     * 添加或更新对象的标签。
     *
     * @param bucketName 存储桶名称
     * @param object 对象名称
     * @param addTags 要添加或更新的标签集合
     * @return 如果操作成功则返回true，否则返回false。
     */
    boolean addTags(String bucketName, String object, Map<String, String> addTags);

    /**
     * 获取对象的状态信息。
     *
     * @param bucketName 存储桶名称
     * @param object 对象名称
     * @return 对象的状态信息。
     */
    StatObjectResponse statObject(String bucketName, String object);

    /**
     * 检查存储桶中对象是否存在。
     *
     * @param bucketName 存储桶名称
     * @param objectName 对象名称
     * @return 如果对象存在则返回true，否则返回false。
     */
    boolean ifExistObject(String bucketName, String objectName);

    /**
     * 从其他对象名中提取元名称。
     *
     * @param objectName 对象名称
     * @return 提取的元名称。
     */
    String getMetaNameFromOther(String objectName);

    /**
     * 更改对象的标签。
     *
     * @param object 对象名称
     * @param tag 新的标签值
     * @return 如果更改成功则返回true，否则返回false。
     */
    boolean changeTag(String object, String tag);

    /**
     * 设置存储桶的公共访问权限。
     *
     * @param bucketName 存储桶名称
     */
    void BucketAccessPublic(String bucketName);
}

MinioServiceImpl

import com.aspose.cad.internal.Y.S;
import com.xagxsj.erms.model.BucketName;
import com.xagxsj.erms.model.ObjectTags;
import com.xagxsj.erms.service.MinioService;
import com.xagxsj.erms.utils.FileUtil;
import io.minio.*;
import io.minio.errors.*;
import io.minio.http.Method;
import io.minio.messages.Bucket;
import io.minio.messages.Item;
import io.minio.messages.Tags;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.io.InputStream;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.logging.Logger;

import static com.xagxsj.erms.model.BucketName.METADATA;

@Service
public class MinioServiceImpl implements MinioService {
    private final Logger log = Logger.getLogger(this.getClass().getName());
    @Qualifier("getMinioClient")
    @Autowired
    MinioClient minioClient;

    /**
     * 检查指定的存储桶是否存在于MinIO服务器上。
     *
     * @param bucketName 要检查的存储桶名称。
     * @return 如果存储桶存在，则返回true；否则返回false。
     */
    @Override
    public boolean ifExistsBucket(String bucketName) {
        boolean result = false;
        try {
            result = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
        } catch (ErrorResponseException e) {
            e.printStackTrace();
            return false;
        } catch (InsufficientDataException | InternalException | InvalidKeyException | InvalidResponseException | IOException | NoSuchAlgorithmException | ServerException | XmlParserException e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 在MinIO服务器上创建一个新的存储桶。
     *
     * @param bucketName 要创建的存储桶名称。
     * @throws RuntimeException 如果尝试创建一个已存在的存储桶，则抛出此异常。
     * @return 如果存储桶创建成功，则返回true；否则返回false。
     */
    @Override
    public boolean createBucket(String bucketName) throws RuntimeException {
        if (ifExistsBucket(bucketName)) {
            throw new RuntimeException("桶已存在");
        }
        try {
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
        } catch (ErrorResponseException | InsufficientDataException | InternalException | InvalidKeyException | InvalidResponseException | IOException | NoSuchAlgorithmException | ServerException | XmlParserException e) {
            e.printStackTrace();
        }
        return ifExistsBucket(bucketName);
    }

    /**
     * 从MinIO服务器上删除一个存储桶。
     *
     * @param bucketName 要删除的存储桶名称。
     * @return 如果存储桶成功删除，则返回true；如果存储桶不存在，则返回true；否则返回false。
     */
    @Override
    public boolean removeBucket(String bucketName) {
        if (!ifExistsBucket(bucketName)) {
            return true;
        }
        try {
            minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
        } catch (ErrorResponseException | InsufficientDataException | InternalException | InvalidKeyException | InvalidResponseException | IOException | NoSuchAlgorithmException | ServerException | XmlParserException e) {
            e.printStackTrace();
        }
        return !ifExistsBucket(bucketName);
    }

    /**
     * 列出MinIO服务器上所有存在的存储桶。
     *
     * @return 返回一个包含所有存储桶信息的列表。
     */
    @Override
    public List<Bucket> alreadyExistBuckets() {
        List<Bucket> buckets = null;
        try {
            buckets = minioClient.listBuckets();
        } catch (ErrorResponseException | InsufficientDataException | InternalException | InvalidKeyException | InvalidResponseException | IOException | NoSuchAlgorithmException | ServerException | XmlParserException e) {
            e.printStackTrace();
        }
        return buckets;
    }

    /**
     * 检查指定的文件是否存在于存储桶中。
     *
     * @param bucketName 存储桶名称。
     * @param filename 要检查的文件名。
     * @param recursive 是否递归搜索子目录。
     * @return 如果文件存在，则返回true；否则返回false。
     */
    @Override
    public boolean fileifexist(String bucketName, String filename, boolean recursive) {
        boolean flag = false;
        Iterable<Result<Item>> results = minioClient.listObjects(ListObjectsArgs.builder()
                .bucket(bucketName)
                .prefix(filename)
                .recursive(recursive)
                .maxKeys(1000)
                .build());
        for (Result<Item> result : results) {
            try {
                Item item = result.get();
                if (item.objectName().equals(filename)) {
                    flag = true;
                    break;
                }
            } catch (ErrorResponseException | InsufficientDataException | InternalException | InvalidKeyException | InvalidResponseException | IOException | NoSuchAlgorithmException | ServerException | XmlParserException e) {
                e.printStackTrace();
            }
        }
        return flag;
    }

    /**
     * 列出存储桶中所有对象，可指定前缀和是否递归搜索子目录。
     *
     * @param bucketName 存储桶名称。
     * @param predir 前缀过滤器。
     * @param recursive 是否递归搜索子目录。
     * @return 返回一个包含所有匹配对象的结果列表。
     */
    @Override
    public List<Result<Item>> listObjects(String bucketName, String predir, boolean recursive) {
        Iterable<Result<Item>> results = minioClient.listObjects(ListObjectsArgs.builder()
                .bucket(bucketName)
                .prefix(predir)
                .recursive(recursive)
                .maxKeys(1000)
                .build());
        List<Result<Item>> list = new ArrayList<>();
        results.forEach(list::add);
        return list;
    }

    /**
     * 构建存储桶中对象的ComposeSource列表，用于复合对象操作。
     *
     * @param bucketName 存储桶名称。
     * @param predir 前缀过滤器。
     * @return 返回一个包含所有匹配对象的ComposeSource列表。
     */
    @Override
    public List<ComposeSource> listObjects(String bucketName, String predir) {
        Iterable<Result<Item>> results = minioClient.listObjects(ListObjectsArgs.builder()
                .bucket(bucketName)
                .prefix(predir)
                .recursive(true)
                .maxKeys(1000)
                .build());
        List<Result<Item>> list = new ArrayList<>();
        results.forEach(list::add);

        List<ComposeSource> sources = new ArrayList<>();
        for (Result<Item> itemResult : list) {
            try {
                sources.add(ComposeSource.builder().bucket(bucketName).object(itemResult.get().objectName()).build());
            } catch (ErrorResponseException | InsufficientDataException | InternalException | InvalidKeyException | InvalidResponseException | IOException | NoSuchAlgorithmException | ServerException | XmlParserException e) {
                e.printStackTrace();
            }
        }
        return sources;
    }


    /**
     * 复制一个对象到新的存储桶或新的对象名称。
     *
     * @param pastBucket  原始存储桶名称
     * @param pastObject  原始对象名称
     * @param newBucket   新的存储桶名称
     * @param newObject   新的对象名称
     * @return 如果复制成功，则返回true；否则返回false。
     */
    @Override
    public boolean copyObject(String pastBucket, String pastObject, String newBucket, String newObject) {
        try {
            ObjectWriteResponse response = minioClient.copyObject(
                    CopyObjectArgs.builder()
                            .bucket(newBucket)
                            .object(newObject)
                            .source(
                                    CopySource.builder()
                                            .bucket(pastBucket)
                                            .object(pastObject)
                                            .build())
                            .build());
        } catch (ErrorResponseException e) {
            e.printStackTrace();
            return false;
        } catch (InsufficientDataException | InternalException | InvalidKeyException | InvalidResponseException | IOException | NoSuchAlgorithmException | ServerException | XmlParserException e) {
            e.printStackTrace();
        }
        return true;
    }

    /**
     * 下载存储桶中的对象到本地文件系统。
     *
     * @param bucketName  存储桶名称
     * @param objectName  对象名称
     * @param targetPath  本地目标路径
     * @return 如果下载成功，则返回true；否则返回false。
     */
    @Override
    public boolean downObject(String bucketName, String objectName, String targetPath) {
        try {
            if ("".equals(objectName) || null == objectName) {
                throw new RuntimeException("检查电子文件FilePath是否为空，下载目标位置为：" + targetPath);
            }
            minioClient.downloadObject(
                    DownloadObjectArgs.builder()
                            .bucket(bucketName)
                            .object(objectName)
                            .filename(targetPath)      //download local path
                            .build());
        } catch (ErrorResponseException e) {
            e.printStackTrace();
            return false;
        } catch (InsufficientDataException | InternalException | InvalidKeyException | InvalidResponseException | IOException | NoSuchAlgorithmException | ServerException | XmlParserException e) {
            e.printStackTrace();
        }
        return true;
    }

    /**
     * 获取存储桶中对象的预签名URL（GET方法）。
     *
     * @param bucketName  存储桶名称
     * @param object      对象名称
     * @param expire      过期时间（分钟）
     * @return 预签名URL，如果发生错误则返回null。
     */
    @Override
    public String presignedURLofObject(String bucketName, String object, int expire) {
        String url = null;
        try {
            url = minioClient.getPresignedObjectUrl(
                    GetPresignedObjectUrlArgs.builder()
                            .method(Method.GET)
                            .bucket(bucketName)
                            .object(object)
                            .expiry(expire, TimeUnit.MINUTES)
                            .build());
        } catch (ErrorResponseException | InsufficientDataException | InternalException | InvalidKeyException | InvalidResponseException | IOException | NoSuchAlgorithmException | XmlParserException | ServerException e) {
            e.printStackTrace();
        }
        return url;
    }

    /**
     * 获取存储桶中对象的预签名URL，允许设置额外的查询参数。
     *
     * @param bucketName  存储桶名称
     * @param object      对象名称
     * @param expire      过期时间（分钟）
     * @param map         额外的查询参数
     * @return 预签名URL，如果发生错误则返回空字符串。
     */
    @Override
    public String presignedURLofObject(String bucketName, String object, int expire, Map<String, String> map) {
        map.put("response-content-type", "application/json");
        String presignedObjectUrl = "";
        try {
            presignedObjectUrl = minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
                    .bucket(bucketName)
                    .object(object)
                    .method(Method.GET)
                    .expiry(expire, TimeUnit.MINUTES)
                    .extraQueryParams(map)
                    .build());
        } catch (ErrorResponseException | InsufficientDataException | InternalException | InvalidKeyException | InvalidResponseException | IOException | NoSuchAlgorithmException | XmlParserException | ServerException e) {
            e.printStackTrace();
        }
        return presignedObjectUrl;
    }

    /**
     * 删除存储桶中的对象。
     *
     * @param bucketName  存储桶名称
     * @param object      对象名称
     * @return 如果删除成功，则返回true；否则返回false。
     */
    @Override
    public boolean deleteObject(String bucketName, String object) {
        try {
            minioClient.removeObject(RemoveObjectArgs.builder()
                    .bucket(bucketName)
                    .object(object)
                    .build());
        } catch (ErrorResponseException e) {
            e.printStackTrace();
            return false;
        } catch (InsufficientDataException | InternalException | InvalidKeyException | InvalidResponseException | IOException | NoSuchAlgorithmException | ServerException | XmlParserException e) {
            e.printStackTrace();
        }
        return true;
    }

    /**
     * 将本地文件上传至MinIO存储桶。
     *
     * @param bucketName     存储桶名称
     * @param targetObject   目标对象名称
     * @param sourcePath     源文件路径
     * @return 如果上传成功，则返回true；否则返回false。
     */
    @Override
    public boolean uploadObject(String bucketName, String targetObject, String sourcePath) {
        try {
            minioClient.uploadObject(UploadObjectArgs.builder()
                    .bucket(bucketName)
                    .object(targetObject)
                    .filename(sourcePath)
                    .build());
        } catch (ErrorResponseException | InsufficientDataException | InternalException | InvalidKeyException | InvalidResponseException | IOException | NoSuchAlgorithmException | ServerException | XmlParserException e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 将输入流数据写入MinIO存储桶。
     *
     * @param bucketName 存储桶名称
     * @param object     对象名称
     * @param inputStream 输入流
     * @return 如果写入成功，则返回true；否则返回false。
     */
    @Override
    public boolean putObject(String bucketName, String object, InputStream inputStream) {
        try {
            minioClient.putObject(PutObjectArgs.builder()
                    .bucket(bucketName)
                    .object(object)
                    .stream(inputStream, -1, 10485760)
                    .build());
        } catch (ErrorResponseException | InsufficientDataException | InternalException | InvalidKeyException | InvalidResponseException | IOException | NoSuchAlgorithmException | ServerException | XmlParserException e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 将带有标签的输入流数据写入MinIO存储桶。
     *
     * @param bucketName 存储桶名称
     * @param object     对象名称
     * @param inputStream 输入流
     * @param tags       对象标签
     * @return 如果写入成功，则返回true；否则返回false。
     */
    @Override
    public boolean putObject(String bucketName, String object, InputStream inputStream, Map<String, String> tags) {
        try {
            minioClient.putObject(PutObjectArgs.builder()
                    .bucket(bucketName)
                    .object(object)
                    .stream(inputStream, -1, 10485760)
                    .tags(tags)
                    .build());
        } catch (ErrorResponseException | InsufficientDataException | InternalException | InvalidKeyException | InvalidResponseException | IOException | NoSuchAlgorithmException | ServerException | XmlParserException e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 从MinIO存储桶获取对象。
     *
     * @param bucketName 存储桶名称
     * @param object     对象名称
     * @return 返回对象响应信息，如果发生错误则返回null。
     */
    @Override
    public GetObjectResponse getObject(String bucketName, String object) {
        GetObjectResponse object1 = null;
        try {
            object1 = minioClient.getObject(GetObjectArgs.builder()
                    .bucket(bucketName)
                    .object(object)
                    .build());
        } catch (ErrorResponseException | InsufficientDataException | InternalException | InvalidKeyException | InvalidResponseException | IOException | NoSuchAlgorithmException | ServerException | XmlParserException e) {
            e.printStackTrace();
        }
        return object1;
    }

    /**
     * 获取对象的标签信息。
     *
     * @param bucketName 存储桶名称
     * @param object     对象名称
     * @return 返回对象的标签映射，如果发生错误则返回null。
     */
    @Override
    public Map<String, String> getTags(String bucketName, String object) {
        Map<String, String> map = new HashMap<>();
        try {
            Tags objectTags = minioClient.getObjectTags(GetObjectTagsArgs.builder()
                    .bucket(bucketName)
                    .object(object)
                    .build());
            map = objectTags.get();
        } catch (ErrorResponseException | InsufficientDataException | InternalException | InvalidKeyException | InvalidResponseException | IOException | NoSuchAlgorithmException | ServerException | XmlParserException e) {
            e.printStackTrace();
            return null;
        }
        return map;
    }

    /**
     * 向对象添加或更新标签。
     *
     * @param bucketName 存储桶名称
     * @param object     对象名称
     * @param addTags    要添加或更新的标签映射
     * @return 如果操作成功，则返回true；否则返回false。
     */
    @Override
    public boolean addTags(String bucketName, String object, Map<String, String> addTags) {
        Map<String, String> oldtags = new HashMap<>();
        Map<String, String> newTags = new HashMap<>();
        try {
            oldtags = getTags(bucketName, object);
            if (oldtags.size() > 0) {
                newTags.putAll(oldtags);
            }
            if (addTags != null && addTags.size() > 0) {
                newTags.putAll(addTags);
            }
            minioClient.setObjectTags(SetObjectTagsArgs.builder()
                    .bucket(bucketName)
                    .object(object)
                    .tags(newTags)
                    .build());
            return true;
        } catch (ErrorResponseException | InsufficientDataException | InternalException | InvalidKeyException | InvalidResponseException | IOException | NoSuchAlgorithmException | ServerException | XmlParserException e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 获取对象的状态信息。
     *
     * @param bucketName 存储桶名称
     * @param object     对象名称
     * @return 返回对象状态信息，如果发生错误则返回null。
     */
    @Override
    public StatObjectResponse statObject(String bucketName, String object) {
        StatObjectResponse statObject = null;
        try {
            statObject =
                    minioClient.statObject(
                            StatObjectArgs.builder()
                                    .bucket(bucketName)
                                    .object(object)
                                    .build());
        } catch (ErrorResponseException | InsufficientDataException | InternalException | InvalidKeyException | InvalidResponseException | IOException | NoSuchAlgorithmException | ServerException | XmlParserException e) {
            e.printStackTrace();
        }
        return statObject;
    }

    /**
     * 判断存储桶中是否存在指定对象。
     *
     * @param bucketName   存储桶名称
     * @param objectName   对象名称
     * @return 如果存在，则返回true；否则返回false。
     */
    @Override
    public boolean ifExistObject(String bucketName, String objectName) {
        return listObjects(bucketName, objectName, true).size() >= 1;
    }

    /**
     * 从元数据存储桶中获取与特定对象相关的元数据对象名。
     *
     * @param objectName 原始对象名称
     * @return 返回编码后的元数据对象名，如果没有找到对应的元数据则返回其文件名。
     */
    @Override
    public String getMetaNameFromOther(String objectName) {
        String metaobject = "";
        List<Result<Item>> results = listObjects(BucketName.METADATA, FileUtil.getPreMeta(objectName), true);
        if (results.size() == 1) {
            try {
                metaobject = results.get(0).get().objectName();
                Map<String, String> tags = getTags(BucketName.METADATA, metaobject);
                String s = tags.get(ObjectTags.FILENAME);
                // 解码后再编码以确保正确处理特殊字符
                // URLDecoder.decode(s,"UTF-8");
                return URLEncoder.encode(s, "UTF-8");
            } catch (ErrorResponseException | InsufficientDataException | InternalException | InvalidKeyException | InvalidResponseException | IOException | NoSuchAlgorithmException | ServerException | XmlParserException e) {
                e.printStackTrace();
            }
        }
        return FileUtil.getFileName(metaobject);
    }

    /**
     * 修改对象的标签信息。
     *
     * @param object 对象名称
     * @param tag 新的标签值
     * @return 如果修改成功，则返回true；否则返回false。
     */
    @Override
    public boolean changeTag(String object, String tag) {
        try {
            Map<String, String> map = minioClient.getObjectTags(GetObjectTagsArgs.builder()
                    .bucket(BucketName.METADATA)
                    .object(object)
                    .build()).get();

            Map<String, String> map1 = new HashMap<>();
            tag = tag + FileUtil.getSuffix(object);
            map1.put(ObjectTags.FILENAME, tag);
            map1.put(ObjectTags.OPERATOR, map.get(ObjectTags.OPERATOR));

            minioClient.setObjectTags(SetObjectTagsArgs.builder()
                    .bucket(BucketName.METADATA)
                    .object(object)
                    .tags(map1)
                    .build());
            return true;
        } catch (ErrorResponseException | InsufficientDataException | InternalException | InvalidKeyException | InvalidResponseException | IOException | NoSuchAlgorithmException | ServerException | XmlParserException e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 设置存储桶的访问策略为公开访问。
     *
     * @param bucketName 存储桶名称
     */
    @Override
    public void BucketAccessPublic(String bucketName) {
        String config = "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]},\"Action\":[\"s3:ListBucketMultipartUploads\",\"s3:GetBucketLocation\",\"s3:ListBucket\"],\"Resource\":[\"arn:aws:s3:::" + bucketName + "\"]},{\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]},\"Action\":[\"s3:ListMultipartUploadParts\",\"s3:PutObject\",\"s3:AbortMultipartUpload\",\"s3:DeleteObject\",\"s3:GetObject\"],\"Resource\":[\"arn:aws:s3:::" + bucketName + "/*\"]}]}";
        try {
            minioClient.setBucketPolicy(SetBucketPolicyArgs.builder().bucket(bucketName).config(config).build());
        } catch (ErrorResponseException | InsufficientDataException | InternalException | InvalidKeyException | InvalidResponseException | IOException | NoSuchAlgorithmException | ServerException | XmlParserException e) {
            e.printStackTrace();
        }
    }

}
minio

与MinIO使用记录相似的内容：

MinIO使用记录

探索MinIO：高性能、分布式对象存储解决方案 注：本文除代码外多数为AI生成 最近因为有项目需要换成Amazon S3的云存储，所以把之前做过的minio部分做一个记录，后面也会把基于这版改造的S3方法发出来记录。 MinIO简介 MinIO是一款高性能、分布式对象存储服务器，设计用于在大规模环境

minio
23
最快速搭建个人服务器图床siuuuuu

@目录1.服务器准备2.docker 安装(1)通过命令行的方式(2)宝塔面板上安装3.开启端口访问什么是docker4.docker安装minio什么是minio5.配置minio6.picgo下载与配置 本文记录使用docker+minio+picgo超快速搭建自己服务器个人图床！ 1.服务器准

快速 搭建 个人 服务器
38
minio性能测试

# minio性能测试 ## minio的使用 ``` 前期使用了s3fs 但是想验证一下性能相关, 所以使用今天简单验证了一下, 其实也可以使用一下fio 但是s3fs 是对象存储 没有修改 只有上传, 所以感觉还是使用dd更加好一些. ``` ## dd 性能测试脚本-读取 ``` rm -rf

minio 性能 测试
91
[转帖]如何使用 minio 进行 BR 备份

https://tidb.net/blog/ada69456#5.%20%E4%BD%BF%E7%94%A8%20minio%20%E8%BF%9B%E8%A1%8C%20BR%20%E5%A4%87%E4%BB%BD%E7%9A%84%E6%9D%83%E9%99%90%E8%AF%B4%E6%9

如何 使用 minio 进行
0
Tidb 使用minio 进行br备份数据库的过程

# Tidb 使用minio 进行br备份数据库的过程 ## 背景 ``` br 备份恢复时一般需要共享存储. 前段时间一直使用的是nfs 进行共享文件备份. 这样需要所有的机器在 相同的目录下面挂载相同的nfs. 并且是需要有读写权限. 所以nfs 就比较复杂了. 而且需要有宿主机的权限比较难以实

tidb 使用 minio 进行
42
[转帖]使用s3(minio)为kubernetes提供pv存储

http://www.lishuai.fun/2021/12/31/k8s-pv-s3/#/%E8%A6%81%E6%B1%82 我们可以通过csi使用s3为kubernetes提供pv存储，当我们申请pvc时，会自动在s3上创建bucket。这里我们还使用minio作为s3使用。 注: 不建议生产

使用 s3 minio kubernetes
0
[转帖]使用s3(minio)为kubernetes提供pv存储

http://www.lishuai.fun/2021/12/31/k8s-pv-s3/#/%E8%A6%81%E6%B1%82 我们可以通过csi使用s3为kubernetes提供pv存储，当我们申请pvc时，会自动在s3上创建bucket。这里我们还使用minio作为s3使用。 注: 不建议生产

使用 s3 minio kubernetes
0
Windows 挂载minio 到本地磁盘

# Windows 挂载minio 到本地磁盘 ## 背景 ``` 新公司建议使用minio 进行一些业务操作 已经在各位领导同事的帮助下找到了linux本地s3fs挂载和k8s使用csi方式挂载到pod内的方式. 今天一个帮助过我的同事想用windows平台进行联调. 我感觉很有必要解决这个联调的

windows 挂载 minio 本地
272
[转帖]rclone将本地文件或文件夹导入minio中

1、背景：公司数据迁移涉及到文件迁移，原有文件服务器没有使用minio,但是现在的新系统使用了minio。所以这就需要我们将文件上传到minio文件服务器中；由于历史文件数据量大，甲方要求可以通过服务器文件拷贝方式迁移文件，性能、安全性更高； 2、前期准备： 1）minio文件服务器已经安装完成；

rclone 本地 文件 文件夹
0
[转帖]使用Rclone实现minio数据的迁移

使用Rclone实现minio数据的迁移 一、准备 1.1 使用工具 rclone：开源的对象存储在线迁移工具，用于文件和目录的同步，支持阿里云的oss、minio 、亚马逊S3 等。 1.2 注意事项 1、两台机器的时区及时间要保持一致，最后进行迁移之前，两台机器的时间进行校准。方法如下： #ce

使用 rclone 实现 minio
0
# 热门排行
微软 New Bing AI 申请与使用保姆级教程（免魔法） ChatGPT API使用介绍 ChatGPT开发实战 一篇带你了解如何使用纯前端类Excel表格构建现金流量表 手把手教你玩转 Excel 数据透视表 为什么 C# 可能是最好的第一编程语言 .NET 入门到高级路线 提高工作效率的神器：基于前端表格实现Chrome Excel扩展插件 React + Springboot + Quartz，从0实现Excel报表自动化 用Echarts实现前端表格引用从属关系可视化
© PmDaddy. 2023 PmDaddy教程网 All rights reserved.