精华内容
下载资源
问答
  • minio文件服务器
    2021-08-06 09:25:10

    Docker 容器安装MinIO文件服务器

    稳定版

    docker pull minio/minio

    注意:启动,此命令在容器关闭时数据自动消失。

    docker run -p 9000:9000 minio/minio server /data

    安装后使用浏览器访问http://127.0.0.1:9000,如果可以访问,则表示minio已经安装成功。

    5ad3cbba2dd7649effa234bc900c53d6.png

    要创建具有永久存储的Minio容器,您需要将本地持久目录从主机操作系统映射到虚拟配置~/.minio 并导出/data目录。 为此,请运行以下命令

    docker run -d -p 9000:9000 --name minio-server \

    -e "MINIO_ACCESS_KEY=systex" \

    -e "MINIO_SECRET_KEY=minioadmin" \

    -v /home/systex/env/minio/data:/data \

    -v /home/systex/env/minio/config:/root/.minio \

    minio/minio server /data

    获取容器ID

    在容器中使用Docker命令, 你需要知道这个容器的 容器ID 。 为了获取 Container ID, 运行

    docker ps -a

    -a flag 确保你获取所有的容器(创建的,正在运行的,退出的),然后从输出中识别Container ID。

    启动和停止容器

    启动容器,你可以使用 docker start 命令。

    docker start

    停止一下正在运行的容器, 使用 docker stop 命令。

    docker stop

    Minio容器日志

    获取Minio日志,使用 docker logs 命令。

    docker logs

    监控MinioDocker容器

    监控Minio容器使用的资源,使用 docker stats 命令.

    docker stats

    注意服务器时间同步问题

    minio 上传下载文件失败 (The difference between the request time and the server’s time is too large.)

    minio上传下载文件失败:

    错误消息:

    The difference between the request time and the server's time is too large.

    原因:linux服务器时区的问题。

    解决方案:

    一、查看系统时间、硬件时间

    1.# date // 查看系统时间

    2.#hwclock // 查看硬件时间

    二、时间服务器上的时间同步的方法

    安装ntpdate工具

    1.# yum -y install ntp ntpdate

    设置系统时间与网络时间同步

    2.# ntpdate cn.pool.ntp.org

    将系统时间写入硬件时间

    3.# hwclock --systohc

    容器构建时采用和宿主机相同的时间即可。执行以下命令来快速构建 -v /etc/localtime:/etc/localtime 同步时间参数

    docker run -d -p 9000:9000 --name minio-server \

    -e "MINIO_ACCESS_KEY=systex" \

    -e "MINIO_SECRET_KEY=minioadmin" \

    -v /data/systex/env/minio/data:/data \

    -v /data/systex/env/minio/config:/root/.minio \

    -v /etc/localtime:/etc/localtime \

    minio/minio server /data

    标签:容器,MinIO,server,构建,9000,服务器,docker,data,minio

    来源: https://blog.csdn.net/u010259933/article/details/110429759

    更多相关内容
  • minio 文件服务器

    2020-07-10 21:48:20
    minio 文件服务器环境搭建/以及示例代码,方便搭建文件服务器,代码包含传统的本地保存、minio保存、s3保存等示例代码。
  • minio 文件服务器工具

    2021-06-14 17:45:26
    minio 文件服务器工具
  • minio文件服务器(windows版) 1、包含minio server二进制文件; 2、包含minio client二进制文件; 3、内置start.bat一键启动程序; 4、包含windows服务自动安装配置及程序。
  • MinIO 是一款基于Go语言的高性能对象存储服务,在Github上已有19K+Star。它采用了Apache License v2.0开源协议,非常适合于存储大容量非结构化的数据,...minio文件服务器Windows版,操作简便,轻松搭建一个文件服务器
  • MinIO文件服务器

    2020-12-24 14:04:54
    MinIO文件服务器 目前可用于文件存储的网络服务选择有很多,比如阿里云OSS、七牛云、腾讯云等等。FastDFS与MinIO文件服务器 MinIO是根据Apache许可v2.0发布的高性能对象存储。它与Amazon S3云存储服务兼容。使用...

    MinIO文件服务器


    目前可用于文件存储的网络服务选择有很多,比如阿里云OSS、七牛云、腾讯云等等。FastDFS与MinIO文件服务器

    MinIO是根据Apache许可v2.0发布的高性能对象存储。它与Amazon S3云存储服务兼容。使用MinIO构建用于机器学习,分析和应用程序数据工作负载的高性能基础架构。

    功能特性

    [1] Amazon S3兼容Minio使用Amazon S3 v2 / v4 API。可以使用Minio SDK,Minio Client,AWS SDK和AWS CLI访问Minio服务器。

    [2] 数据保护Minio使用Minio Erasure Code来防止硬件故障。也许会损坏一半以上的driver,但是仍然可以从中恢复。

    [3] 高度可用Minio服务器可以容忍分布式设置中高达(N / 2)-1节点故障。而且,您可以配置Minio服务器在Minio与任意Amazon S3兼容服务器之间存储数据。

    [4] Lambda计算Minio服务器通过其兼容AWS SNS / SQS的事件通知服务触发Lambda功能。支持的目标是消息队列,如Kafka,NATS,AMQP,MQTT,Webhooks以及Elasticsearch,Redis,Postgres和MySQL等数据库。

    [5] 加密和防篡改Minio为加密数据提供了机密性,完整性和真实性保证,而且性能开销微乎其微。使用AES-256-GCM,ChaCha20-Poly1305和AES-CBC支持服务器端和客户端加密。加密的对象使用AEAD服务器端加密进行防篡改。

    [6] 可对接后端存储除了Minio自己的文件系统,还支持DAS、 JBODs、NAS、Google云存储和Azure Blob存储。

    [7] SDK支持基于Minio轻量的特点,它得到类似Java、Python或Go等语言的sdk支持,例如: Java类在使用Maven管理Jar的情况下,在pom.xml中指定Minio:

    <dependency>

          <groupId>io.minio</groupId>

          <artifactId>minio</artifactId>

          <version>7.0.2</version>

    </dependency>

    官方网站: https://min.io/

    安装教程网址: https://docs.minio.io/

    windows安装

    在官方网站上下载minio.exe

    下载地址:https://dl.min.io/server/minio/release/windows-amd64/minio.exe

     

     

    MINIO_ACCESS_KEY设置账号

    MINIO_SECRET_KEY设置密码

    Minio.exe server --address :9999 C:\pro_minio\minio 设置端口号

    如果不设置默认是(minioadmin/minioadmin)

    运行run_minio.bat文件

    再浏览器中输入127.0.0.1:9000 输入账号密码(admin/12345678) 

    minio制作服务启动

    需要借助"Windows Service Wrapper"小工具,

    下载地址: http://repo.jenkins-ci.org/releases/com/sun/winsw/winsw/1.18/winsw-1.18-bin.exe

    winsw-1.18-bin.exe拷贝到minio目录(与minio.exe在同一目录),再把winsw-1.18-bin.exe改名为minio-service.exe

    新建 minio-service.xml 

    <service>

      <id>minio</id>

      <name>MinIO Service</name>

      <description>MinIO is a High Performance Object Storage</description>

      <logpath>C:\minio\logs</logpath>

      <log mode="roll-by-size">

        <sizeThreshold>10240</sizeThreshold>

        <keepFiles>8</keepFiles>

      </log>

      <executable>C:\minio\run.bat</executable>

    </service>

    minio.exe当成服务开机启动,以管理员身份运行cmd,使用安装服务命令如下:

    安装服务 minio-service.exe install (cmd下执行这行)

    卸载服务 minio-service.exe uninstall

    进入系统服务,启动服务即可

    展开全文
  • MinIO文件服务器,从安装到使用

    千次阅读 2022-05-21 20:36:17
    mino安装以及封装上传下载工具类,提供上传接口,数据表设计,上传异常处理,minio配置

    以往的项目,用的比较多的OSS服务是腾讯云和阿里云的存储服务,不过从去年到今年,最近的几个项目,普遍要使用Minio,所以我在开发服务器和测试服务器上都装上了minio

    一、首先minio的安装

    MInIO的安装有很多方法、单实例的、集群分布式的、docker部署的、支持k8s的,我们使用最简单的一种安装方式:linux单节点安装。

    如果希望对MinIO有深入的掌握,访问MinIO官网:https://min.io

    1.1 安装工作

    首先在/root目录下创建一个minio文件夹

    cd /root
    mkdir minio
    cd minio
    wget https://dl.min.io/server/minio/release/linux-amd64/minio
    
    

    等待下载完成后:

    在当前minio目录下,会出现一个minio目录

    chmod +x minio
    
    # 创建minio文件存储目录及日志目录
    mkdir -p /root/data/minio;
    mkdir -p /root/logs/minio;
    

    然后在 /root/minio/目录下,新建一个run.sh并编辑以下内容

    vim run.sh,然后将以下内容保存到run.sh,并为其赋予执行权限chmod u+x run.sh

    #!/bin/bash
    export MINIO_ROOT_USER=fsp-manage
    export MINIO_ROOT_PASSWORD=springboot-fsp-manage
    # nohup启动服务 指定文件存放路径 /root/data 还有设置日志文件路径 /root/minio/log
    nohup ./minio server --address :9002 --console-address :9001 /root/data/minio > /root/logs/minio/minio.log 2>&1 &

    注意:以前的老版本minio的配置中,配置用户名和密码时,是这两个参数:

    MINIO_ACCESS_KEY 和MINIO_SECRET_KEY

    而现在比较新的版本的minio,需要替换成MINIO_ROOT_USER和MINIO_ROOT_PASSWORD

    并且用户名和密码都是由长度限制的,用户名长度不能小于3,密码不能小于8个字符

    当然,minio安装完成,以及配置完成后,启动项目的run.sh的时候,如果你设置的用户名和密码长度不够,会有警告提示的,还有就是如果你的配置参数写成以前的旧版本的参数,也会提示你替换成对应的MINIO_ROOT_USER和MINIO_ROOT_PASSWORD

    --address :9002 --console-address :9001 是配置端口,默认minio端口是9000,如果9000端口被占用了,那就加上这一串配置,端口号的冒号之前不需要特意写出ip,当然如果你的ip的动态变化的,而不是静态的话,前边的ip不用写上,当然最好是用静态的ip

    然后启动minio

    # 启动minio服务
    bash run.sh
    # 查看日志
    tail -200f /root/logs/minio/minio.log
    

     

     

    然后会有日志打印信息,然后可以看到minio服务器地址,和控制台信息地址

    然后在浏览器中访问地址

    http://192.168.0.131:9002,输入这个地址后会重定向到控制台登录地址http://192.168.0.131:9001/login

    然后在登录界面输入用户名和密码即可登录

     然后登录后进入首页,创建一个bucket

    创建一个fsp-test,区分开发环境和测试环境,当然我在开发环境服务器上创建的是fsp-dev,由于当前在开发阶段,所以项目中我也配置的是fsp-dev这个桶

     

    接下来我以开发环境中的桶演示minio文件的上传和下载等

    二,springboot项目整合MinIO的javaSDK

    2.1 项目的pom文件中引入minio依赖

     <properties>
            <maven.compiler.source>8</maven.compiler.source>
            <maven.compiler.target>8</maven.compiler.target>
            <minio.version>7.1.0</minio.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>io.minio</groupId>
                <artifactId>minio</artifactId>
                <version>${minio.version}</version>
            </dependency>
       </dependencies>

    2.2 在application-dev.yml文件中配置minio

    minio:
      endpoint: http://serverip
      port: 9002
      accessKey: fsp-manage
      secretKey: springboot-fsp-manage
      bucketName: fsp-dev
      secure: false
    
    spring:
         mvc:
          hiddenmethod:
            filter:
              enabled: true
    #        设置文件上传大小限制
      servlet:
        multipart:
          max-file-size: 100MB
          max-request-size: 150MB

    2.3 创建minio配置类和工具类

    配置类:

    package com.xiaomifeng1010.minio.configuration;
    
    import io.minio.MinioClient;
    import io.minio.errors.InvalidPortException;
    import lombok.Getter;
    import lombok.Setter;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.stereotype.Component;
    
    /**
     * @author xiaomifeng1010
     * @version 1.0
     * @date: 2022/5/20 10:30
     * @Description minio配置
     */
    @Configuration
    @Component
    @ConfigurationProperties(prefix = "minio")
    @Getter
    @Setter
    public class MinioConfig {
        private String endpoint;
        private int port;
        private String accessKey;
        private String secretKey;
        private Boolean secure;
        private String bucketName;
    
        @Bean
        public MinioClient getMinioClient() throws InvalidPortException {
            MinioClient minioClient = MinioClient.builder().endpoint(endpoint, port, secure)
                    .credentials(accessKey, secretKey)
                    .build();
            return minioClient;
        }
    //
    //    @Bean(name = "multipartResolver")
    //    public MultipartResolver multipartResolver(){
    //        CommonsMultipartResolver resolver = new CommonsMultipartResolver();
    //        resolver.setDefaultEncoding("UTF-8");
    //        //resolveLazily属性启用是为了推迟文件解析,以在在UploadAction中捕获文件大小异常
    //        resolver.setResolveLazily(true);
    //        resolver.setMaxInMemorySize(40960);
    //        //上传文件大小 50M 50*1024*1024
    //        resolver.setMaxUploadSize(50*1024*1024);
    //        return resolver;
    //    }
    }
    
    

     工具类:

    package com.xiaomifeng.minio.util;
    
    import io.minio.*;
    import io.minio.errors.*;
    import io.minio.http.Method;
    import io.minio.messages.Bucket;
    import io.minio.messages.DeleteError;
    import io.minio.messages.DeleteObject;
    import io.minio.messages.Item;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.lang.StringUtils;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    import org.springframework.web.multipart.MultipartFile;
    
    import javax.servlet.ServletOutputStream;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    import java.io.InputStream;
    import java.nio.charset.StandardCharsets;
    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * MinIO 客户端工具类
     */
    @Component
    @Slf4j
    public class MinioClientUtils {
    
        @Autowired
        private MinioClient minioClient;
    
        private static final int DEFAULT_EXPIRY_TIME = 7 * 24 * 3600;
    
        /**
         * 检查存储桶是否存在
         *
         * @param bucketName 存储桶名称
         * @return boolean
         */
        public boolean bucketExists(String bucketName) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
            boolean flag = false;
            flag = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
            if (flag) {
                return true;
            }
            return false;
        }
    
        /**
         * 创建存储桶
         *
         * @param bucketName 存储桶名称
         */
        public boolean makeBucket(String bucketName) throws IOException, InvalidKeyException, InvalidResponseException, RegionConflictException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
            boolean flag = bucketExists(bucketName);
            if (!flag) {
                minioClient.makeBucket(
                        MakeBucketArgs.builder()
                                .bucket(bucketName)
                                .build());
                return true;
            } else {
                return false;
            }
        }
    
        /**
         * 列出所有存储桶名称
         *
         * @return List<String>
         */
        public List<String> listBucketNames() throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException {
            List<Bucket> bucketList = listBuckets();
            List<String> bucketListName = new ArrayList<>();
            for (Bucket bucket : bucketList) {
                bucketListName.add(bucket.name());
            }
            return bucketListName;
        }
    
        /**
         * 列出所有存储桶
         *
         * @return List<Bucket>
         */
        public List<Bucket> listBuckets() throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
            return minioClient.listBuckets();
        }
    
        /**
         * 删除存储桶
         *
         * @param bucketName 存储桶名称
         * @return boolean
         */
        public boolean removeBucket(String bucketName) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
            boolean flag = bucketExists(bucketName);
            if (flag) {
                Iterable<Result<Item>> myObjects = listObjects(bucketName);
                for (Result<Item> result : myObjects) {
                    Item item = result.get();
                    // 有对象文件,则删除失败
                    if (item.size() > 0) {
                        return false;
                    }
                }
                // 删除存储桶,注意,只有存储桶为空时才能删除成功。
                minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
                flag = bucketExists(bucketName);
                if (!flag) {
                    return true;
                }
    
            }
            return false;
        }
    
        /**
         * 列出存储桶中的所有对象名称
         *
         * @param bucketName 存储桶名称
         * @return List<String>
         */
        public List<String> listObjectNames(String bucketName) throws XmlParserException, IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, InvalidBucketNameException, InsufficientDataException, InternalException {
            List<String> listObjectNames = new ArrayList<>();
            boolean flag = bucketExists(bucketName);
            if (flag) {
                Iterable<Result<Item>> myObjects = listObjects(bucketName);
                for (Result<Item> result : myObjects) {
                    Item item = result.get();
                    listObjectNames.add(item.objectName());
                }
            }
            return listObjectNames;
        }
    
        /**
         * 列出存储桶中的所有对象
         *
         * @param bucketName 存储桶名称
         * @return Iterable<Result<Item>>
         */
        public Iterable<Result<Item>> listObjects(String bucketName) throws XmlParserException, IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, InvalidBucketNameException, InsufficientDataException, InternalException {
            boolean flag = bucketExists(bucketName);
            if (flag) {
                return minioClient.listObjects( ListObjectsArgs.builder().bucket(bucketName).build());
            }
            return null;
        }
    
        /**
         * 通过文件上传到对象
         *
         * @param bucketName 存储桶名称
         * @param objectName 存储桶里的对象名称
         * @param fileName   File name
         * @return boolean
         */
        public boolean uploadObject(String bucketName, String objectName, String fileName) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
            boolean flag = bucketExists(bucketName);
            if (flag) {
                minioClient.uploadObject(
                        UploadObjectArgs.builder()
                                .bucket(bucketName).object(objectName).filename(fileName).build());
                ObjectStat statObject = statObject(bucketName, objectName);
                if (statObject != null && statObject.length() > 0) {
                    return true;
                }
            }
            return false;
    
        }
    
        /**
         * 文件上传
         *
         * @param bucketName 存储捅名称
         * @param multipartFile 文件
         * @param filename   文件名
         */
        public void putObject(String bucketName, MultipartFile multipartFile, String filename) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
            PutObjectOptions putObjectOptions = new PutObjectOptions(multipartFile.getSize(), PutObjectOptions.MIN_MULTIPART_SIZE);
            putObjectOptions.setContentType(multipartFile.getContentType());
            minioClient.putObject(
                    PutObjectArgs.builder().bucket(bucketName).object(filename).stream(
                            multipartFile.getInputStream(), multipartFile.getSize(), -1).contentType(multipartFile.getContentType())
                            .build());
        }
    
        /**
         * 通过InputStream上传对象
         *
         * @param bucketName 存储桶名称
         * @param objectName 存储桶里的对象名称
         * @param inputStream     要上传的流
         * @param contentType 上传的文件类型 例如 video/mp4  image/jpg
         * @return boolean
         */
        public boolean putObject(String bucketName, String objectName, InputStream inputStream,String contentType) throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException {
            boolean flag = bucketExists(bucketName);
            if (flag) {
                minioClient.putObject(PutObjectArgs.builder().bucket(bucketName).object(objectName).stream(
                        //不清楚文件的大小时,可以传-1,10485760。如果知道大小也可以传入size,partsize。
                        inputStream,  -1, 10485760)
                        .contentType(contentType)
                        .build());
                ObjectStat statObject = statObject(bucketName, objectName);
                if (statObject != null && statObject.length() > 0) {
                    return true;
                }
            }
            return false;
        }
    
        /**
         * 以流的形式获取一个文件对象
         *
         * @param bucketName 存储桶名称
         * @param objectName 存储桶里的对象名称
         * @return InputStream
         */
        public InputStream getObject(String bucketName, String objectName) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
            boolean flag = bucketExists(bucketName);
            if (flag) {
                ObjectStat statObject = statObject(bucketName, objectName);
                if (statObject != null && statObject.length() > 0) {
                    InputStream stream = minioClient.getObject( GetObjectArgs.builder()
                            .bucket(bucketName)
                            .object(objectName)
                            .build());
                    return stream;
                }
            }
            return null;
        }
    
        /**
         * 以流的形式获取一个文件对象(断点下载)
         *
         * @param bucketName 存储桶名称
         * @param objectName 存储桶里的对象名称
         * @param offset     起始字节的位置
         * @param length     要读取的长度 (可选,如果无值则代表读到文件结尾)
         * @return InputStream
         */
        public InputStream getObject(String bucketName, String objectName, long offset, Long length) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
            boolean flag = bucketExists(bucketName);
            if (flag) {
                ObjectStat statObject = statObject(bucketName, objectName);
                if (statObject != null && statObject.length() > 0) {
                    InputStream stream = minioClient.getObject(  GetObjectArgs.builder()
                            .bucket(bucketName)
                            .object(objectName)
                            .offset(1024L)
                            .length(4096L)
                            .build());
                    return stream;
                }
            }
            return null;
        }
    
        /**
         * 下载并将文件保存到本地
         *
         * @param bucketName 存储桶名称
         * @param objectName 存储桶里的对象名称
         * @param fileName   File name
         * @return boolean
         */
        public boolean downloadObject(String bucketName, String objectName, String fileName) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
            boolean flag = bucketExists(bucketName);
            if (flag) {
                ObjectStat statObject = statObject(bucketName, objectName);
                if (statObject != null && statObject.length() > 0) {
                    minioClient.downloadObject(DownloadObjectArgs.builder()
                            .bucket(bucketName)
                            .object(objectName)
                            .filename(fileName)
                            .build());
                    return true;
                }
            }
            return false;
        }
    
        /**
         * 删除一个对象
         *
         * @param bucketName 存储桶名称
         * @param objectName 存储桶里的对象名称
         */
        public boolean removeObject(String bucketName, String objectName) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
            boolean flag = bucketExists(bucketName);
            if (flag) {
                minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(objectName).build());
                return true;
            }
            return false;
        }
    
        /**
         * 删除指定桶的多个文件对象,返回删除错误的对象列表,全部删除成功,返回空列表
         *
         * @param bucketName  存储桶名称
         * @param objectNames 含有要删除的多个object名称的迭代器对象
         * @return
         * eg:
         * List<DeleteObject> objects = new LinkedList<>();
         * objects.add(new DeleteObject("my-objectname1"));
         * objects.add(new DeleteObject("my-objectname2"));
         * objects.add(new DeleteObject("my-objectname3"));
         */
        public List<String> removeObjects(String bucketName, List<DeleteObject> objectNames) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
            List<String> deleteErrorNames = new ArrayList<>();
            boolean flag = bucketExists(bucketName);
            if (flag) {
                Iterable<Result<DeleteError>> results = minioClient.removeObjects(RemoveObjectsArgs.builder().bucket(bucketName).objects(objectNames).build());
                for (Result<DeleteError> result : results) {
                    DeleteError error = result.get();
                    deleteErrorNames.add(error.objectName());
                }
            }
            return deleteErrorNames;
        }
    
        /**
         * 生成一个给HTTP GET请求用的presigned URL。
         * 浏览器/移动端的客户端可以用这个URL进行下载,即使其所在的存储桶是私有的。这个presigned URL可以设置一个失效时间,默认值是7天。
         *
         * @param bucketName 存储桶名称
         * @param objectName 存储桶里的对象名称
         * @param expires    失效时间(以秒为单位),默认是7天,不得大于七天
         * @return
         */
        public String getPresignedObjectUrl(String bucketName, String objectName, Integer expires) throws InvalidExpiresRangeException, IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException {
            boolean flag = bucketExists(bucketName);
            String url = "";
            if (flag) {
                if (expires < 1 || expires > DEFAULT_EXPIRY_TIME) {
                    throw new InvalidExpiresRangeException(expires,
                            "expires must be in range of 1 to " + DEFAULT_EXPIRY_TIME);
                }
                try {
                    url = minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
                            .method(Method.GET)
                            .bucket(bucketName)
                            .object(objectName)
                            .expiry(expires)//动态参数
                            //                       .expiry(24 * 60 * 60)//用秒来计算一天时间有效期
    //                        .expiry(1, TimeUnit.DAYS)//按天传参
    //                        .expiry(1, TimeUnit.HOURS)//按小时传参数
                            .build());
                } catch (ErrorResponseException | InsufficientDataException | InternalException | InvalidBucketNameException | InvalidExpiresRangeException | InvalidKeyException | InvalidResponseException | IOException | NoSuchAlgorithmException | ServerException | XmlParserException e) {
                    e.printStackTrace();
                }
            }
            return url;
        }
    
        /**
         * 生成一个给HTTP PUT请求用的presigned URL。
         * 浏览器/移动端的客户端可以用这个URL进行上传,即使其所在的存储桶是私有的。这个presigned URL可以设置一个失效时间,默认值是7天。
         *
         * @param bucketName 存储桶名称
         * @param objectName 存储桶里的对象名称
         * @param expires    失效时间(以秒为单位),默认是7天,不得大于七天
         * @return String
         */
        public String presignedPutObject(String bucketName, String objectName, Integer expires) throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException {
            boolean flag = bucketExists(bucketName);
            String url = "";
            if (flag) {
                if (expires < 1 || expires > DEFAULT_EXPIRY_TIME) {
                    try {
                        throw new InvalidExpiresRangeException(expires,
                                "expires must be in range of 1 to " + DEFAULT_EXPIRY_TIME);
                    } catch (InvalidExpiresRangeException e) {
                        e.printStackTrace();
                    }
                }
                try {
                    url = minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
                            .method(Method.PUT)
                            .bucket(bucketName)
                            .object(objectName)
                            .expiry(expires)//动态参数
                            //                       .expiry(24 * 60 * 60)//用秒来计算一天时间有效期
    //                        .expiry(1, TimeUnit.DAYS)//按天传参
    //                        .expiry(1, TimeUnit.HOURS)//按小时传参数
                            .build());
                } catch (ErrorResponseException | InsufficientDataException e) {
                    e.printStackTrace();
                } catch (InternalException e) {
                    log.error("InternalException",e);
                } catch (InvalidBucketNameException e) {
                    log.error("InvalidBucketNameException",e);
                } catch (InvalidExpiresRangeException e) {
                    log.error("InvalidExpiresRangeException",e);
                } catch (InvalidKeyException e) {
                    log.error("InvalidKeyException",e);
                } catch (InvalidResponseException e) {
                    log.error("InvalidResponseException",e);
                } catch (IOException e) {
                    log.error("IOException",e);
                } catch (NoSuchAlgorithmException e) {
                    log.error("NoSuchAlgorithmException",e);
                } catch (ServerException e) {
                    log.error("ServerException",e);
                } catch (XmlParserException e) {
                    log.error("XmlParserException",e);
                }
            }
            return url;
        }
    
        /**
         * 获取对象的元数据
         *
         * @param bucketName 存储桶名称
         * @param objectName 存储桶里的对象名称
         * @return
         */
        public ObjectStat statObject(String bucketName, String objectName) throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException {
            boolean flag = bucketExists(bucketName);
            if (flag) {
                ObjectStat statObject = null;
                try {
                    statObject = minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build());
                } catch (ErrorResponseException e) {
                    log.error("ErrorResponseException",e);
                } catch (InsufficientDataException e) {
                    log.error("ErrorResponseException",e);
                    e.printStackTrace();
                } catch (InternalException e) {
                    log.error("InternalException",e);
                } catch (InvalidBucketNameException e) {
                    log.error("InvalidBucketNameException",e);
                } catch (InvalidKeyException e) {
                    log.error("InvalidKeyException",e);
                } catch (InvalidResponseException e) {
                    log.error("InvalidResponseException",e);
                } catch (IOException e) {
                    log.error("IOException",e);
                } catch (NoSuchAlgorithmException e) {
                    log.error("NoSuchAlgorithmException",e);
                } catch (ServerException e) {
                    log.error("ServerException",e);
                } catch (XmlParserException e) {
                    log.error("XmlParserException",e);
                }
                return statObject;
            }
            return null;
        }
    
        /**
         * 文件访问路径
         *
         * @param bucketName 存储桶名称
         * @param objectName 存储桶里的对象名称
         * @return String
         */
        public String getObjectUrl(String bucketName, String objectName) throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException {
            boolean flag = bucketExists(bucketName);
            String url = "";
            if (flag) {
                try {
                    url = minioClient.getObjectUrl(bucketName, objectName);
                } catch (ErrorResponseException e) {
                    log.error("XmlParserException",e);
                } catch (InsufficientDataException e) {
                    log.error("InsufficientDataException",e);
                } catch (InternalException e) {
                    log.error("InternalException",e);
                } catch (InvalidBucketNameException e) {
                    log.error("InvalidBucketNameException",e);
                } catch (InvalidKeyException e) {
                    log.error("InvalidKeyException",e);
                } catch (InvalidResponseException e) {
                    log.error("InvalidResponseException",e);
                } catch (IOException e) {
                    log.error("IOException",e);
                } catch (NoSuchAlgorithmException e) {
                    log.error("NoSuchAlgorithmException",e);
                } catch (ServerException e) {
                    log.error("ServerException",e);
                } catch (XmlParserException e) {
                    log.error("XmlParserException",e);
                }
            }
            return url;
        }
    
    
    
        public void downloadFile(String bucketName, String fileName, String originalName, HttpServletResponse response) {
            try {
    
                InputStream file = minioClient.getObject(GetObjectArgs.builder()
                        .bucket(bucketName)
                        .object(fileName)
                        .build());
                String filename = new String(fileName.getBytes("ISO8859-1"), StandardCharsets.UTF_8);
                if (StringUtils.isNotEmpty(originalName)) {
                    fileName = originalName;
                }
                response.setHeader("Content-Disposition", "attachment;filename=" + filename);
                ServletOutputStream servletOutputStream = response.getOutputStream();
                int len;
                byte[] buffer = new byte[1024];
                while ((len = file.read(buffer)) > 0) {
                    servletOutputStream.write(buffer, 0, len);
                }
                servletOutputStream.flush();
                file.close();
                servletOutputStream.close();
            } catch (ErrorResponseException e) {
                log.error("ErrorResponseException",e);
            } catch (Exception e) {
                log.error("Exception",e);
            }
        }
    }
    
    

    2.3 创建一个数据表,用于保存上传到minio的文件的信息

    CREATE TABLE `minio_file` (
      `id` bigint(20) NOT NULL COMMENT '文件id',
      `original_file_name` varchar(255) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '原始文件名称',
      `file_ext_name` varchar(15) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '文件拓展名',
      `file_size` bigint(20) DEFAULT NULL COMMENT '文件大小(单位:字节)',
      `file_name` varchar(35) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '存入minio时的文件名称',
      `mime` varchar(50) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '文件的content-type',
      `file_url` varchar(255) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '文件路径',
      `is_delete` tinyint(1) DEFAULT NULL COMMENT '是否删除 0 否 1 是',
      `create_by` varchar(25) COLLATE utf8mb4_bin DEFAULT NULL,
      `create_time` datetime DEFAULT NULL,
      `update_by` varchar(25) COLLATE utf8mb4_bin DEFAULT NULL,
      `update_time` datetime DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin;

    然后使用idea自动代码生成插件,生成对应的实体类,mapper和service层

    2.4 创建minio上传接口

    package com.dcboot.module.minio.controller;
    
    import cn.hutool.core.io.FileUtil;
    import com.dcboot.base.util.ApiResult;
    import com.dcboot.module.minio.configuration.MinioConfig;
    import com.dcboot.module.minio.dto.response.MinioResponseDTO;
    import com.dcboot.module.minio.entity.MinioFile;
    import com.dcboot.module.util.MinioClientUtils;
    import io.swagger.annotations.Api;
    import io.swagger.annotations.ApiImplicitParam;
    import io.swagger.annotations.ApiOperation;
    import lombok.AllArgsConstructor;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.collections4.CollectionUtils;
    import org.apache.commons.lang3.RandomStringUtils;
    import org.apache.commons.lang3.math.NumberUtils;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.*;
    import org.springframework.web.multipart.MultipartFile;
    
    import java.io.FileInputStream;
    import java.time.Instant;
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * @author xiaomifeng1010
     * @version 1.0
     * @date: 2022/5/21 10:33
     * @Description  minio 文件处理(上传,下载,获取文件地址等)
     */
    @Controller
    @RequestMapping("/fileHandle")
    @Slf4j
    @AllArgsConstructor
    @Api(tags = "文件处理模块")
    public class FileHandleController {
    
        private MinioClientUtils minioClientUtils;
    
        private MinioConfig minioConfig;
    
        @PostMapping(value = {"/admin/uploadFile","/web/uploadFile"})
        @ResponseBody
        @ApiOperation(value = "上传文件,支持批量上传")
        @ApiImplicitParam(name = "files",value = "文件对象",dataType = "File")
        public ApiResult uploadFile(@RequestParam("files") List<MultipartFile> files) {
            log.info(files.toString());
            if (CollectionUtils.isEmpty(files)){
                return ApiResult.error("未选择文件!");
            }
    
            List<MinioResponseDTO> MinioResponseDTOList=new ArrayList<>();
            for (MultipartFile file : files) {
                String originalFilename = file.getOriginalFilename();
    //            获取文件拓展名
                String extName = FileUtil.extName(originalFilename);
                log.info("文件拓展名:"+extName);
    //            生成新的文件名,存入到minio
                long millSeconds = Instant.now().toEpochMilli();
                String minioFileName=millSeconds+ RandomStringUtils.randomNumeric(12)+"."+extName;
                String contentType = file.getContentType();
                log.info("文件mime:{}",contentType);
    //            返回文件大小,单位字节
                long size = file.getSize();
                log.info("文件大小:"+size);
                try {
                    String bucketName = minioConfig.getBucketName();
                    minioClientUtils.putObject(bucketName,file,minioFileName);
                    String fileUrl = minioClientUtils.getObjectUrl(bucketName, minioFileName);
                    MinioFile minioFile = new MinioFile();
                    minioFile.setOriginalFileName(originalFilename);
                    minioFile.setFileExtName(extName);
                    minioFile.setFileName(minioFileName);
                    minioFile.setFileSize(size);
                    minioFile.setMime(contentType);
                    minioFile.setIsDelete(NumberUtils.INTEGER_ZERO);
                    minioFile.setFileUrl(fileUrl);
                    boolean insert = minioFile.insert();
                    if (insert) {
                        MinioResponseDTO minioResponseDTO = new MinioResponseDTO();
                        minioResponseDTO.setFileId(minioFile.getId());
                        minioResponseDTO.setOriginalFileName(originalFilename);
                        minioResponseDTO.setFileUrl(fileUrl);
                        MinioResponseDTOList.add(minioResponseDTO);
                    }
    
    
    
                } catch (Exception e) {
                    log.error("上传文件出错:{}",e);
                    return ApiResult.error("上传文件出错");
    
                }
            }
    
            return ApiResult.success(MinioResponseDTOList);
        }
    
    
        /**
         * 仅仅用于测试,是否可以正常上传文件
         * @return
         * @throws Exception
         */
        @GetMapping("/test")
        @ApiOperation(value = "测试minio文件上传")
        public ApiResult testPutObject() throws Exception {
            FileInputStream fileInputStream = new FileInputStream("C:\\Users\\MSI\\Desktop\\新建文本文档.txt");
            boolean bs = minioClientUtils.putObject("fsp-dev", "新建文本文档.txt", fileInputStream, "image/jpg");
            log.info("上传成功?"+bs);
            return ApiResult.success("上传成功");
        }
    
    
    }
    

    为了在上传文件后,把问价地址返回给前端,所以封装了一个返回数据对象DTO

    package com.dcboot.module.minio.dto.response;
    
    import lombok.Data;
    
    /**
     * @author xiaomifeng1010
     * @version 1.0
     * @date: 2022/5/21 14:03
     * @Description
     */
    @Data
    public class MinioResponseDTO {
    
        private  Long fileId;
    
        private String fileUrl;
    
        private String originalFileName;
    }
    

    然后启动项目在knife4j文档页面测试,或者在postman中测试

     由于设置了文件上传的最大限制,所以超出100兆,会抛出异MaxUploadSizeExceededException

    ,所以需要在全局异常处理器中处理

    package com.dcboot.module.exception.handler;
    
    import com.dcboot.base.handler.GlobalExceptionHandler;
    import com.dcboot.base.util.ApiResult;
    import com.dcboot.base.util.StatusEnum;
    import com.dcboot.module.exception.EnterpriseBusinessException;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.lang3.StringUtils;
    import org.apache.tomcat.util.http.fileupload.impl.FileSizeLimitExceededException;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.core.Ordered;
    import org.springframework.core.annotation.Order;
    import org.springframework.http.HttpStatus;
    import org.springframework.validation.BindException;
    import org.springframework.validation.BindingResult;
    import org.springframework.validation.FieldError;
    import org.springframework.web.bind.MethodArgumentNotValidException;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.RestControllerAdvice;
    import org.springframework.web.multipart.MaxUploadSizeExceededException;
    
    import javax.validation.ConstraintViolation;
    import javax.validation.ConstraintViolationException;
    import java.util.stream.Collectors;
    
    /**
     * @author xiaomifeng1010
     * @version 1.0
     * @date: 2022/5/21 15:51
     * @Description 全局异常处理器
     */
    @RestControllerAdvice
    @Order(value = Ordered.HIGHEST_PRECEDENCE)
    @Slf4j
    public class FSPExceptionHandler extends GlobalExceptionHandler {
    
        @Value("${spring.servlet.multipart.max-file-size}")
        private String maxFileSize;
    
        @ExceptionHandler(value = MethodArgumentNotValidException.class)
        public ApiResult handleValidException(MethodArgumentNotValidException exception) {
            BindingResult result = exception.getBindingResult();
            String errorMessage = StringUtils.EMPTY;
            if (result.hasErrors()) {
                errorMessage = result.getFieldErrors().stream().map(FieldError::getDefaultMessage).collect(Collectors.joining(","));
                log.error("请求对象[{}]验证错误信息{}", result.getFieldErrors().get(0).getObjectName(), errorMessage);
            }
            return ApiResult.error(HttpStatus.BAD_REQUEST.value(), errorMessage);
        }
    
        @ExceptionHandler(value = BindException.class)
        public ApiResult handleValidException(BindException exception) {
            BindingResult result = exception.getBindingResult();
            String errorMessage = StringUtils.EMPTY;
            if (result.hasErrors()) {
                errorMessage = result.getFieldErrors().stream().map(FieldError::getDefaultMessage).collect(Collectors.joining(","));
                log.error("请求对象[{}]验证错误信息{}", result.getFieldErrors().get(0).getObjectName(), errorMessage);
            }
            return ApiResult.error(HttpStatus.BAD_REQUEST.value(), errorMessage);
        }
    
    
        @ExceptionHandler(value = {MaxUploadSizeExceededException.class})
        public ApiResult handleValidException(MaxUploadSizeExceededException exception) {
            long maxUploadSize = exception.getMaxUploadSize();
            log.error("允许的最大上传字节为:{}",maxUploadSize);
            String errorMessage = "文件大于最大限制"+maxFileSize+",请重新上传";
            log.error(errorMessage);
            return ApiResult.error(HttpStatus.BAD_REQUEST.value(), errorMessage);
        }
    
        @Override
        @ExceptionHandler({ConstraintViolationException.class})
        public ApiResult handleConstraintValidationException(final ConstraintViolationException ex) {
            String errorMessage = ex.getConstraintViolations().stream().map(ConstraintViolation::getMessage).collect(Collectors.joining(","));
            return ApiResult.error(HttpStatus.BAD_REQUEST.value(), errorMessage);
    
        }
    
    
    
        @ExceptionHandler({EnterpriseBusinessException.class})
        public ApiResult handEnterpriseBusinessException(EnterpriseBusinessException e) {
            log.error("当前请求出现业务异常!", e);
            return ApiResult.error(e.getCode(), e.getMessage());
        }
    
    
        @Override
        @ExceptionHandler({Exception.class})
        public ApiResult handleUnknownException(final Exception ex) {
            if (ex instanceof MaxUploadSizeExceededException || ex instanceof FileSizeLimitExceededException) {
                String errorMessage = "文件超出限制,请重新上传";
                return ApiResult.error(errorMessage);
            }
            log.error("==> Error {} detected when request", ex.getMessage(), ex);
            return ApiResult.error(StatusEnum.INTERNAL_SERVER_ERROR);
        }
    
    
    }

     接着再postman中上传一个100多兆的sql脚本文件

    会提示超出文件最大限制 

    展开全文
  • MinIO文件服务使用

    MinIO是基于Apache License v2.0开源协议的对象存储服务。兼容亚马逊S3云存储服务接口,非常适合于存储大容量非结构化的数据,例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等,而一个对象文件可以是任意大小,从几kb到最大5T不等。MinIO是一个非常轻量的服务,可以很简单地和其他应用结合。它是为性能和S3 API而设计的。

    官网
    中国镜像站
    中文文档
    开源地址
    .NET 客户端api地址
    下载地址
    minio-dotnet


    安装MinIO服务器

    # 下载minio服务器
    wget http://dl.minio.org.cn/server/minio/release/linux-amd64/minio
    chmod +x minio
    # 把minio文件移动到/usr/local/bin/
    mv minio /usr/local/bin/
    # 尽量不要把文件直接放在/data下,在data下创建一个文件夹aws_s3
    mkdir /data/aws_s3
    # 启动服务
    minio server /data/aws_s3/
    # 自定义节点和端口
    minio server 23.102.55.10:8888 /data/aws_s3/
    # 后台启动
    nohup minio server /data/aws_s3/ &
    # 自定义用户名、密码:在~/.bashrc文件中写入:(重新启动服务)
    export MINIO_ACCESS_KEY=rx
    export MINIO_SECRET_KEY=rx1234
    

    启动服务后,会显示一些ip地址。在浏览器访问这些ip地址,输入用户名密码即可访问本地的MinIO服务器。页面如图:
    在这里插入图片描述
    点击右下角可以创建分区,新建的分区及上传的文件会存储在本地:/data/aws_s3/下


    用MinIO Client(mc)管理文件服务器

    # 下载minio客户端
    wget http://dl.minio.org.cn/client/mc/release/linux-amd64/mc
    chmod +x mc
    ./mc –help
    alias mc="~/mc"
    # 将MinIO Server添加到客户端
    ./mc config host add myminio http://172.21.110.235:9000 rx rx1234
    # 命令行管理文件【命令与linux类似】
    mc mb minio/buk2   						# 创建 buk2 的桶
    mc cp -r * minio/buk2  					# 上传当前目录所有文件到buk2桶上
    mc ls minio  							# 查看存储桶
    mc ls minio/buk2  						# 查看buk2存储桶文件
    mc find minio/buk2 --name "*.html"  	# 查找buk2存储桶中html结尾文件
    mc share download minio/buk2/baidu.html # 共享buk2下baidu.html文件下载路径
    mc policy set public minio/buk2  		# 设置桶策略为public,这样MinIO可以提供永久文件服务
    

    python处理minio文档

    安装:pip install minio
    存储桶里不能再创建桶,其他一切都是对象.
    注:创建桶命名限制:只能用小写字母,句点,连字符和数字(大写字母、下划线等命名会报错),长度至少应为3个字符。
    上传文件:若文件已存在,会直接覆盖
    文件不存在,会报错FileNotFoundError

    # 创建一个客户端
    client = Minio('minio.***.com',
        access_key='admin', 
        secret_key='****', 
        secure=False, 
        )
    # 下载文件
    client.fget_object(
        bucket_name="", 
        object_name="", 
        file_path='', 
        )
    # 上传文件
    client.fput_object(
    	bucket_name='', 
    	object_name='',  # 文件在minio上的路径
    	file_path='',  # 文件在本地的路径
    	)
    

    put_object
    单个对象最大不超过5TB,在对象大于5MiB时,自动使用multiple parts方式上传。这样,当上传失败时,客户端只需要上传未成功的部分即可(类似断点上传)。上传的对象使用MD5SUM签名进行完整性验证。

    非常详细的参考
    中文文档

    展开全文
  • Java+MinIO进行文件管理
  • 安装Minio文件服务器

    2022-05-01 12:01:38
    安装Minio - Minio快速入门 文档链接:http://docs.minio.org.cn/docs/ Minio有什么好处 在大数据领域,通常的设计理念都是无中心和分布式。Minio分布式模式可以帮助你搭建一个高可用的对象存储服务,你可以使用这些...
  • minio 文件服务器搭建

    2020-09-08 16:50:00
    https://blog.csdn.net/hzw2312/article/details/106077729 ...
  • MinIO是在Apache License v2.0下发布的对象存储服务器。搭建方便、使用起来也非常简单、灵活。
  • linux环境下搭建minio文件服务器

    千次阅读 2022-01-25 17:31:22
    Linux环境下搭建支持https访问的minio文件服务器
  • springboot+minio文件服务器的demo,上传、下载、查看的方法已经封装好,拿过来直接使用
  • 使用 Docker 部署 minio 文件服务器

    千次阅读 2022-03-25 18:22:52
    Docker部署minio记录过程
  • docker实操-minIO文件服务器部署
  • Minio文件服务器部署

    2021-01-28 09:23:41
    一、安装Minio 1.Linux系统中可以打开的文件数量 #查看系统级别的能够打开的文件句柄的数量 cat /proc/sys/fs/file-max #vim /etc/sysctl.conf #使修改配置立即生效 2.Linux进程打开文件最大数量,重启后生效...
  • 最近由于公司需要开发社交相关产品,在开发到动态相关模块的时候,需要考虑到用户发布的图片视频等文件的存储,最后在同事的推荐下使用了minio,这里简单的做一个小小的记录。 minio存储是类似于数据库,你可以...
  • 最近项目需要进行文件上传,需要搭建一个文件服务器,就选中了minio文件服务器,就记录一下linux下搭建minio服务器的过程步骤。 1.minio文件服务器的介绍       Minio 是一个基于Go...
  • docker-compose安装minioversion: '3'services:minio:image: minio/minio:latest # 原镜像`minio/minio:latest`container_name: minio # 容器名...
  • minio.exe 分布式文件服务器_Window版_Mac版
  • 文件上传下载4. web实战演示6. 源码分享 Minio简介 高性能 MinIO 是全球领先的对象存储先锋,目前在全世界有数百万的用户. 在标准硬件上,读/写速度上高达183 GB / 秒 和 171 GB / 秒。 对象存储可以充当主存储层...
  • minio文件服务器-docker docker-compose 搭建部署以及使用大全
  • 项目中需要大量用到从文件服务器获取文件,为了减少一丁点内存的复用,使用了基本的sync.pool,具体代码如下:var defaultBucketName = "worker"var defaultLocation = "us-east-1"var minioServerPool *sync....
  • MinIO 文件服务器简单搭建

    千次阅读 2020-11-11 08:50:39
    MinIO 分布式文件服务器 本地安装 Minio是一个对象存储服务器,在项目中可以用来存储文件,替代本地存储或者ftp存储的功能。 docker 安装 docker run --name minio -d -p 9000:9000 -e MINIO_ACCESS_KEY=admin -e ...
  • 2.wget下载minio的linux版,下载的文件在当前执行命令路径下 wget http://dl.minio.org.cn/server/minio/release/linux-amd64/minio 3.将minio授权转为可执行文件 chmod +x minio 4.将可执行的文件放到/usr/local/...
  • minIO文件服务器

    2021-08-02 09:30:05
    export MINIO_ACCESS_KEY=lichaofeng export MINIO_SECRET_KEY=lichaofeng_pwd nohup /home/michael/minio server /home/michael/minioData > /home/michael/minioData/minio.log 2>&1 & 新版服务...
  • Windows 10安装Minio 文件服务器

    千次阅读 2021-04-09 11:06:56
    1、官网地址: ... 2、github 地址: https://github.com/minio/minio 3、下载地址: ...4、Minio 本地安装 ...4.1、将下载下来的minio.exe放入F:\...其中的F:\minio\date是文件存储的地址 5、访问Minio 服务 在浏览器中
  • 1.minio文件服务器的介绍Minio 是一个基于Go语言的对象存储服务。它实现了大部分亚马逊S3云存储服务接口,可以看做是是S3的开源版本,非常适合于存储大容量非结构化的数据,例如图片、视频、日志文件、备份数据和...
  • MinIO文件服务器快速部署和案例演示

    千次阅读 2020-10-02 19:00:43
    MinIO文件服务器 文章目录前言服务器部署依赖配置SpringBoot配置方法模板类方法使用示例易错点和注意点MinIO的文件上传时文件类型设置的坑 前言 这个MinIO服务用起来比较简单,配置和使用都非常快。 1.博客案例...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,617
精华内容 1,446
关键字:

minio文件服务器

友情链接: VbCler.rar