minio对象存储

最新推荐文章于 2024-03-29 09:01:44 发布
最新推荐文章于 2024-03-29 09:01:44 发布
阅读量1.2k 收藏 4
点赞数
分类专栏： minio 文章标签： 服务器 web app
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/PeterMrWang/article/details/125022353
版权

Minio安装

01、概述

中文官网：http://www.minio.org.cn/

英文官网：https://min.io/

02、Minio是什么？

MinIO 服务器, MinIO 客户端, SDKs 等各种资源下载
遵循Apache license version 2.0开源

构建高性能的云原生数据
机器学习，大数据分析，海量存储的基础架构
MinIO支持各种应用程序数据工作负载
在中国：阿里巴巴、腾讯、百度、中国联通、华为、中国移动等等9000多家企业也都在使用MinIO产品

  • 阿里云OSS ： 上传文件免费，使用收费
  • 自己搭建：Fastdfs但是成本和配置非常负载
  • Minio ： 有OSS存储能力，同时非常漂亮后台管理。安装非常方便，集群非常方便，使用起来和阿里oss存储几乎一模一样。

03、下载安装

参考：http://www.minio.org.cn/download.shtml#/windows

准备工作

  • 准备虚拟机或者云服务器
  • 使用finalshell / xshell 进行远程链接
  • 注意：如果虚拟机最好在学习阶段把防火墙全部关闭
  • 如果是阿里云服务：请注意把对应的端口9100和9000请注意在【安全组】开放。

04、安装MinIO

官网地址：https://docs.min.io

默认安装centos安装如下

mkdir -p /usr/local/minio
cd /usr/local/minio
wget https://dl.min.io/server/minio/release/linux-amd64/minio
chmod +x minio
./minio server /data

默认访问地址是：http://ip:9000/ 默认账号密码是：minioadmin / minioadmin

2、使用修改账号和密码进行安装（使用这个）

mkdir -p /usr/local/minio
cd /usr/local/minio
wget https://dl.min.io/server/minio/release/linux-amd64/minio
chmod +x minio

export MINIO_ROOT_USER=root
export MINIO_ROOT_PASSWORD=12345678
./minio server --console-address 0.0.0.0:9100 /usr/local/minio/data >/usr/local/minio/minio.log 2>&1 &

可以编写sh脚本

新建一个：start.sh

export MINIO_ROOT_USER=root
export MINIO_ROOT_PASSWORD=12345678
./minio server --console-address 0.0.0.0:9100 /usr/local/minio/data >/usr/local/minio/minio.log 2>&1 &

chmod +x start.sh

./start.sh

5、让后访问即可

http://ip:9100/

6、如果你在云服务器，就必须在阿里云的对应ip的安全组中把，9100和9000进行开放即可。

7、创建存储桶Bucket
在这里插入图片描述

05、java对接minio

1：依赖

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

2：定义文件上传类：

2-1、构建一个springboot工程

2-2、配置

application.yml配置如下：

spring:
  servlet:
    multipart:
      # 文件上传大小限制。超过该值直接报错
      max-file-size: 20MB
      # 文件最大请求限制，用于批量上传
      max-request-size: 20MB

# MinIO 配置
minio:
  endpoint: http://139.224.164.101:9000      # MinIO服务地址
  fileHost: http://139.224.164.101:9000      # 文件地址host
  bucketName: pugapp                      # 存储桶bucket名称
  accessKey: root                         # 用户名
  secretKey: 12345678                     # 密码
  imgSize: 20                           # 图片大小限制，单位：m
  fileSize: 20                          # 文件大小限制，单位：m

2-2、定义一个配置类

package com.pug.config.minio;

import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@Data
public class MinIOConfig {

    @Value("${minio.endpoint}")
    private String endpoint;
    @Value("${minio.fileHost}")
    private String fileHost;
    @Value("${minio.bucketName}")
    private String bucketName;
    @Value("${minio.accessKey}")
    private String accessKey;
    @Value("${minio.secretKey}")
    private String secretKey;

    @Value("${minio.imgSize}")
    private Integer imgSize;
    @Value("${minio.fileSize}")
    private Integer fileSize;

    @Bean
    public MinIoUploadService creatMinioClient() {
        return new MinIoUploadService(endpoint, bucketName, accessKey, secretKey, imgSize, fileSize);
    }
}

2-3、编写一个文件上传的类

package com.pug.config.minio;

import io.minio.*;
import io.minio.http.Method;
import io.minio.messages.Bucket;
import io.minio.messages.DeleteObject;
import io.minio.messages.Item;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.multipart.MultipartFile;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Optional;

/**
 * MinIO工具类
 */
@Slf4j
public class MinIoUploadService {

    private MinioClient minioClient;

    private String endpoint;
    private String bucketName;
    private String accessKey;
    private String secretKey;
    private Integer imgSize;
    private Integer fileSize;


    private final String SEPARATOR = "/";

    public MinIoUploadService() {
    }

    public MinIoUploadService(String endpoint, String bucketName, String accessKey, String secretKey, Integer imgSize, Integer fileSize) {
        this.endpoint = endpoint;
        this.bucketName = bucketName;
        this.accessKey = accessKey;
        this.secretKey = secretKey;
        this.imgSize = imgSize;
        this.fileSize = fileSize;
        createMinioClient();
    }

    /**
     * 创建基于Java端的MinioClient
     */
    public void createMinioClient() {
        try {
            if (null == minioClient) {
                log.info("开始创建 MinioClient...");
                minioClient = MinioClient
                        .builder()
                        .endpoint(endpoint)
                        .credentials(accessKey, secretKey)
                        .build();
                createBucket(bucketName);
                log.info("创建完毕 MinioClient...");
            }
        } catch (Exception e) {
            log.error("MinIO服务器异常：{}", e);
        }
    }

    /**
     * 获取上传文件前缀路径
     *
     * @return
     */
    public String getBasisUrl() {
        return endpoint + SEPARATOR + bucketName + SEPARATOR;
    }

    /******************************  Operate Bucket Start  ******************************/

    /**
     * 启动SpringBoot容器的时候初始化Bucket
     * 如果没有Bucket则创建
     *
     * @throws Exception
     */
    private void createBucket(String bucketName) throws Exception {
        if (!bucketExists(bucketName)) {
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
        }
    }

    /**
     * 判断Bucket是否存在，true：存在，false：不存在
     *
     * @return
     * @throws Exception
     */
    public boolean bucketExists(String bucketName) throws Exception {
        return minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
    }


    /**
     * 获得Bucket的策略
     *
     * @param bucketName
     * @return
     * @throws Exception
     */
    public String getBucketPolicy(String bucketName) throws Exception {
        String bucketPolicy = minioClient
                .getBucketPolicy(
                        GetBucketPolicyArgs
                                .builder()
                                .bucket(bucketName)
                                .build()
                );
        return bucketPolicy;
    }


    /**
     * 获得所有Bucket列表
     *
     * @return
     * @throws Exception
     */
    public List<Bucket> getAllBuckets() throws Exception {
        return minioClient.listBuckets();
    }

    /**
     * 根据bucketName获取其相关信息
     *
     * @param bucketName
     * @return
     * @throws Exception
     */
    public Optional<Bucket> getBucket(String bucketName) throws Exception {
        return getAllBuckets().stream().filter(b -> b.name().equals(bucketName)).findFirst();
    }

    /**
     * 根据bucketName删除Bucket，true：删除成功； false：删除失败，文件或已不存在
     *
     * @param bucketName
     * @throws Exception
     */
    public void removeBucket(String bucketName) throws Exception {
        minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
    }

    /******************************  Operate Bucket End  ******************************/


    /******************************  Operate Files Start  ******************************/

    /**
     * 判断文件是否存在
     *
     * @param bucketName 存储桶
     * @param objectName 文件名
     * @return
     */
    public boolean isObjectExist(String bucketName, String objectName) {
        boolean exist = true;
        try {
            minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build());
        } catch (Exception e) {
            exist = false;
        }
        return exist;
    }

    /**
     * 判断文件夹是否存在
     *
     * @param bucketName 存储桶
     * @param objectName 文件夹名称
     * @return
     */
    public boolean isFolderExist(String bucketName, String objectName) {
        boolean exist = false;
        try {
            Iterable<Result<Item>> results = minioClient.listObjects(
                    ListObjectsArgs.builder().bucket(bucketName).prefix(objectName).recursive(false).build());
            for (Result<Item> result : results) {
                Item item = result.get();
                if (item.isDir() && objectName.equals(item.objectName())) {
                    exist = true;
                }
            }
        } catch (Exception e) {
            exist = false;
        }
        return exist;
    }

    /**
     * 根据文件前缀查询文件
     *
     * @param bucketName 存储桶
     * @param prefix     前缀
     * @param recursive  是否使用递归查询
     * @return MinioItem 列表
     * @throws Exception
     */
    public List<Item> getAllObjectsByPrefix(String bucketName,
                                            String prefix,
                                            boolean recursive) throws Exception {
        List<Item> list = new ArrayList<>();
        Iterable<Result<Item>> objectsIterator = minioClient.listObjects(
                ListObjectsArgs.builder().bucket(bucketName).prefix(prefix).recursive(recursive).build());
        if (objectsIterator != null) {
            for (Result<Item> o : objectsIterator) {
                Item item = o.get();
                list.add(item);
            }
        }
        return list;
    }

    /**
     * 获取文件流
     *
     * @param bucketName 存储桶
     * @param objectName 文件名
     * @return 二进制流
     */
    public InputStream getObject(String bucketName, String objectName) throws Exception {
        return minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(objectName).build());
    }

    /**
     * 断点下载
     *
     * @param bucketName 存储桶
     * @param objectName 文件名称
     * @param offset     起始字节的位置
     * @param length     要读取的长度
     * @return 二进制流
     */
    public InputStream getObject(String bucketName, String objectName, long offset, long length) throws Exception {
        return minioClient.getObject(
                GetObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .offset(offset)
                        .length(length)
                        .build());
    }

    /**
     * 获取路径下文件列表
     *
     * @param bucketName 存储桶
     * @param prefix     文件名称
     * @param recursive  是否递归查找，false：模拟文件夹结构查找
     * @return 二进制流
     */
    public Iterable<Result<Item>> listObjects(String bucketName, String prefix,
                                              boolean recursive) {
        return minioClient.listObjects(
                ListObjectsArgs.builder()
                        .bucket(bucketName)
                        .prefix(prefix)
                        .recursive(recursive)
                        .build());
    }

    /**
     * 使用MultipartFile进行文件上传
     *
     * @param bucketName  存储桶
     * @param file        文件名
     * @param objectName  对象名
     * @param contentType 类型
     * @return
     * @throws Exception
     */
    public ObjectWriteResponse uploadFile(String bucketName, MultipartFile file,
                                          String objectName, String contentType) throws Exception {
        InputStream inputStream = file.getInputStream();
        return minioClient.putObject(
                PutObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .contentType(contentType)
                        .stream(inputStream, inputStream.available(), -1)
                        .build());
    }

    /**
     * 上传本地文件
     *
     * @param bucketName 存储桶
     * @param objectName 对象名称
     * @param fileName   本地文件路径
     */
    public ObjectWriteResponse uploadFile(String bucketName, String objectName,
                                          String fileName) throws Exception {
        return minioClient.uploadObject(
                UploadObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .filename(fileName)
                        .build());
    }

    /**
     * 通过流上传文件
     *
     * @param bucketName  存储桶
     * @param objectName  文件对象
     * @param inputStream 文件流
     */
    public ObjectWriteResponse uploadFile(String bucketName, String objectName, InputStream inputStream) throws Exception {
        return minioClient.putObject(
                PutObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .stream(inputStream, inputStream.available(), -1)
                        .build());
    }

    /**
     * 创建文件夹或目录
     *
     * @param bucketName 存储桶
     * @param objectName 目录路径
     */
    public ObjectWriteResponse createDir(String bucketName, String objectName) throws Exception {
        return minioClient.putObject(
                PutObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .stream(new ByteArrayInputStream(new byte[]{}), 0, -1)
                        .build());
    }

    /**
     * 获取文件信息, 如果抛出异常则说明文件不存在
     *
     * @param bucketName 存储桶
     * @param objectName 文件名称
     */
    public String getFileStatusInfo(String bucketName, String objectName) throws Exception {
        return minioClient.statObject(
                StatObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .build()).toString();
    }

    /**
     * 拷贝文件
     *
     * @param bucketName    存储桶
     * @param objectName    文件名
     * @param srcBucketName 目标存储桶
     * @param srcObjectName 目标文件名
     */
    public ObjectWriteResponse copyFile(String bucketName, String objectName,
                                        String srcBucketName, String srcObjectName) throws Exception {
        return minioClient.copyObject(
                CopyObjectArgs.builder()
                        .source(CopySource.builder().bucket(bucketName).object(objectName).build())
                        .bucket(srcBucketName)
                        .object(srcObjectName)
                        .build());
    }

    /**
     * 删除文件
     *
     * @param bucketName 存储桶
     * @param objectName 文件名称
     */
    public void removeFile(String bucketName, String objectName) throws Exception {
        minioClient.removeObject(
                RemoveObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .build());
    }

    /**
     * 批量删除文件
     *
     * @param bucketName 存储桶
     * @param keys       需要删除的文件列表
     * @return
     */
    public void removeFiles(String bucketName, List<String> keys) {
        List<DeleteObject> objects = new LinkedList<>();
        keys.forEach(s -> {
            objects.add(new DeleteObject(s));
            try {
                removeFile(bucketName, s);
            } catch (Exception e) {
                log.error("批量删除失败！error:{}", e);
            }
        });
    }

    /**
     * 获取文件外链
     *
     * @param bucketName 存储桶
     * @param objectName 文件名
     * @param expires    过期时间 <=7 秒 （外链有效时间（单位：秒））
     * @return url
     * @throws Exception
     */
    public String getPresignedObjectUrl(String bucketName, String objectName, Integer expires) throws Exception {
        GetPresignedObjectUrlArgs args = GetPresignedObjectUrlArgs.builder().expiry(expires).bucket(bucketName).object(objectName).build();
        return minioClient.getPresignedObjectUrl(args);
    }

    /**
     * 获得文件外链
     *
     * @param bucketName
     * @param objectName
     * @return url
     * @throws Exception
     */
    public String getPresignedObjectUrl(String bucketName, String objectName) throws Exception {
        GetPresignedObjectUrlArgs args = GetPresignedObjectUrlArgs.builder()
                .bucket(bucketName)
                .object(objectName)
                .method(Method.GET).build();
        return minioClient.getPresignedObjectUrl(args);
    }

    /**
     * 将URLDecoder编码转成UTF8
     *
     * @param str
     * @return
     * @throws UnsupportedEncodingException
     */
    public String getUtf8ByURLDecoder(String str) throws UnsupportedEncodingException {
        String url = str.replaceAll("%(?![0-9a-fA-F]{2})", "%25");
        return URLDecoder.decode(url, "UTF-8");
    }

    /******************************  Operate Files End  ******************************/


}

具体文件上传

package com.pug.controller.upload;

import com.pug.config.minio.MinIOConfig;
import com.pug.config.minio.MinIoUploadService;
import io.swagger.annotations.Api;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

/**
 * @author 飞哥
 * @Title: 学相伴出品
 * @Description: 飞哥B站地址：https://space.bilibili.com/490711252
 * 记得关注和三连哦！
 * @Description: 我们有一个学习网站：https://www.kuangstudy.com
 * @date 2022/3/6 17:25
 */
@RestController
@Api(tags = "文件上传测试的接口")
@Slf4j
public class FileUploadController {

    @Autowired
    private MinIoUploadService minIoUploadService;
    @Autowired
    private MinIOConfig minIOConfig;

    @PostMapping("upload")
    public String upload(MultipartFile file) throws Exception {
        String fileName = file.getOriginalFilename();
        minIoUploadService.uploadFile(minIOConfig.getBucketName(), fileName, file.getInputStream());
        String imgUrl = minIOConfig.getFileHost()
                + "/"
                + minIOConfig.getBucketName()
                + "/"
                + fileName;

        return imgUrl;
    }
}
PeterMrWang
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Windows下安装MinIO
北辰
07-17 1629
MinIO官网地址：http://docs.minio.org.cn/docs/ 通过http://dl.minio.org.cn/server/minio/release/windows-amd64/minio.exe下载windows环境下的安装包： 在D盘下创建一个目录D:\Mino，将minio.exe文件移动到D:\Minio目录下面 创建一个data目录存放文件，创建一个run.bat文件用于启动minio 第一种启动方式：进入到CMD中使用minio.exe server /d
minio对象存储服务
04-21
minio 兼容Amason的S3分布式对象存储项目，采用Golang实现，客户端支持Java,Python,Javacript, Golang语言。 Minio可以做为云存储的解决方案用来保存海量的图片，视频，文档。由于采用Golang实现，服务端可以工作 ...
Minio对象存储及Springboot整合Minio分片上传文章-代码
02-23
Minio对象存储及Springboot整合Minio分片上传文章----代码
docs：MinIO对象存储文档
02-05
MinIO文件 要求 python3（任何版本都可以，最好是最新版本） 建议创建一个虚拟环境以保持事物的简洁明了： 首先克隆存储库。 cd进入克隆的仓库。 您可能需要git fetch刷新存储库。 一旦进入存储库根目录，请运行以下命令。 python3 -m venv venv source venv/bin/activate pip3 install -r requirements.txt nvm install v14.5.0 nvm use v14.5.0 npm install 要进行构建，请执行以下操作： make html 工件以HTML格式输出到build/目录。
MinIO：云原生的对象存储，解锁海量数据的力量
最新发布
u013558123的博客
03-29 599
MinIO 是一款高性能、可扩展性和安全性强的开源对象存储解决方案。它采用对象存储模型和分布式存储架构，提供数据持久性、规模可扩展性和细粒度的访问控制。MinIO 可以广泛应用于数据备份和恢复、数据归档和分析、静态网站托管和文件共享和协作等领域。通过 MinIO，企业可以轻松存储和处理大量数据，提高数据处理能力和效率。
minio-8.0.3-API文档-中文版.zip
07-14
赠送jar包：minio-8.0.3.jar； 赠送原API文档：minio-8.0.3-javadoc.jar； 赠送源代码：minio-8.0.3-sources.jar； 赠送Maven依赖信息文件：minio-8.0.3.pom； 包含翻译后的API文档：minio-8.0.3-javadoc-API文档-中文(简体)版.zip； Maven坐标：io.minio:minio:8.0.3； 标签：minio、中文文档、jar包、java； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。 人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。
基于Linux系统的minio分布式对象存储二进制文件包及启动脚本
12-02
MinIO 是一款基于Go语言发开的高性能、分布式的对象存储系统。客户端支持Java,Net,Python,Javacript, Golang语言。
minio windows版本对象存储
08-09
MinIO 是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几kb到最大5T不等。
MinIO中文官网
weixin_39183923的博客
05-11 6395
MinIO中文官网 MinIO Quickstart Guide| Minio中文文档
MinIO中方官网
weixin_39183923的博客
05-11 477
MinIO | 高性能，对Kubernetes友好的对象存储
搭建文件服务器MinIO，快速上手使用
qq_46540738的博客
02-15 3049
搭建文件服务器MinIO官网简单介绍下载搭建环境运行默认配置、修改配置信息正常访问文件上传 官网         minio 官方网址：https://min.io/         minio 中文镜像网站：http://minio.org.cn/         有时
Windows中Minio的安装和使用
weixin_45579930的博客
07-07 1万+
MinIO 是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几kb到最大5T不等。 MinIO是一个非常轻量的服务,可以很简单的和其他应用的结合，类似 NodeJS, Redis 或者 MySQL。 1.Minio官网地址:https://min.io/ 2.安装启动 在cmd窗口中，命令行进行minio.exe所在的文件夹.
MinIO安装配置访问以及SpringBoot整合MinIO
阿水的博客
04-10 7777
MinIO安装配置访问以及SpringBoot整合MinIO
Minio下载使用并整合springboot
Cloud
07-11 730
Minio使用(整合spring boot)
docker搭建minio
Gang-bb的博客
11-12 810
1.分布式文件系统应用场景 互联网海量非结构化数据的存储需求 电商网站：海量商品图片 视频网站：海量视频文件 网盘：海量文件 社交网站：海量图片 2. minio安装 Minio官网：https://min.io/ docker run \ -p 9000:9000 \ -p 9001:9001 \ -d --restart=always \ -e "MINIO_ROOT_USER=admin" \ -e "MINIO_ROOT_PASSWORD=admin123456" \ -
MinIO详细介绍以及SpringBoot整合MinIO
Xiao_Lata的博客
02-23 3285
MinIO 是一个非常轻量的服务,可以很简单的和其他应用的结合使用，它兼容亚马逊 S3 云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等。官网：https : / / min . io中文：https : / / www . minio . org . cn / ，http : / / docs . minio . org . cn / docs /
minio安装以及使用
jifgnie的博客
10-14 174
nohup端口自定义启动服务 指定文件存放路径 /home/minio/minio 还有设置日志文件路径 /home/minio/minio/log/minio.log。中文下载地址：http://www.minio.org.cn/download.shtml#/linux。Github地址：https://github.com/minio/minio。英文下载地址：https://min.io/download#/linux。中文文档: http://docs.minio.org.cn/docs/
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教程
兴乐安宁的博客
08-20 6181
Minio默认9000端口，在配置文件中加入–address “127.0.0.1:9029” 可更改端口。MINIO_SECRET_KEY：密码，密码不能设置过于简单，不然minio会启动失败，长度最小是8个字符。MINIO_ACCESS_KEY：用户名，长度最小是5个字符。–config-dir：指定集群配置文件目录。集群节点192.168.3.18内容为。集群节点172.16.11.1内容为。修改配置文件后需要重加载配置。...............
minio 对象存储
07-27
Minio是一个基于Apache License v2.0开源协议的工具存储服务，它兼容亚马逊S3云存储服务接口，适用于存储大容量非结构化的数据，比如图片、视频、日志文件、备份数据和容器/虚拟机镜像等。\[1\] Minio具有以下功能特性： 1. Amazon S3兼容：Minio使用Amazon S3 v2/v4 API，可以使用Minio SDK、Minio Client、AWS SDK和AWS CLI访问Minio服务器。 2. 数据保护：Minio使用Minio Erasure Code来防止硬件故障，即使有一半以上的驱动器损坏，数据仍然可以恢复。 3. 高度可用：Minio服务器可以容忍分布式设置中高达（N/2）-1节点故障，并且可以配置在Minio和任意Amazon S3兼容服务器之间存储数据。 4. Lambda计算：Minio服务器通过兼容AWS SNS/SQS的事件通知服务触发Lambda功能，支持的目标包括消息队列（如Kafka、NATS、AMQP、MQTT）、Elasticsearch、Redis、Postgres和MySQL等数据库。 5. 加密和防篡改：Minio提供机密性、完整性和真实性保证的加密数据，使用AES-256-GCM、ChaCha20-Poly1305和AES-CBC支持服务器端和客户端加密。 6. 可对接后端存储：除了Minio自己的文件系统，还支持DAS、JBODs、NAS、Google云存储和Azure Blob存储等后端存储。\[1\] 您可以通过自建Minio对象存储集群的方式来满足对存储服务的需求，特别是在不使用云厂商提供的存储服务的情况下。\[1\] Minio的官方网站是https://min.io/，您可以在该网站上找到更多关于Minio的信息和文档。\[2\] \[3\] #### 引用[.reference_title] - *1* [Minio对象存储](https://blog.csdn.net/weixin_30575309/article/details/99263291)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* *3* [minio对象存储](https://blog.csdn.net/qq_17522211/article/details/126867470)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值