精华内容
下载资源
问答
  • minio断点续传方案

    万次阅读 热门讨论 2020-08-03 17:11:45
    minio断点续传方案一、功能二、特点三、效果四、详细方案 完整代码 一、功能 1、分片上传 2、断点续传 3、秒传 二、特点 1、不暴露minio敏感信息 2、针对文件每一个分片生成相应的上传地址 3、文件直接从浏览器上传...
    完整代码在此
    完整代码在此
    完整代码在此

    一、功能

    1、分片上传
    2、断点续传
    3、秒传

    二、特点

    1、不暴露minio敏感信息
    2、针对文件每一个分片生成相应的上传地址
    3、文件直接从浏览器上传到minio,不经过后台
    4、部署简单,无须部署额外的类似于sts的服务

    三、效果

    1、上传页面
    上传页面
    2、前端上传日志
    前端上传日志
    3、minio上传日志
    minio上传日志

    四、详细方案

    流程图

    前端流程可参考:https://www.cnblogs.com/xiahj/p/vue-simple-uploader.html
    不同之处在于:
    1、根据文件分片生成上传地址
    参考:https://github.com/singularityhub/sregistry/pull/298
    上面这个方案是用python实现的。

    在golang的sdk中,PutObject接口内部在上传文件时会对大文件进行分片,对于每一个分片都有一个requestMetadata.presignURL参数,将此参数设置为true的时候,将会生成一个对应的上传地址,使用此地址我们就可以在web页面将文件直接上传到minio。

    展开全文
  • 基于minio webuploader实现的分片上传 断点续传 ,包含前后台代码 ,可以直接使用
  • springboot断点续传或分片上传
  • 示例是纯净的,后端程序仅引用了需要...后端程序启动时,请确保配置文件里的信息是跟你minio服务信息一致的; 前端程序启动时,请阅读一下“composeFile”函数里的注释 前后端程序都启动完成,直接上传一个文件即可测试
  • 使用spring boot整合google的断点续传框架事项大文件断点续传功能
  • 本篇主要用来说明基于minio文件存储的断点续传及断点下载的解决方案 1.断点续传 断点续传功能采用Tus+Minio结构,其中Minio作为文件存储服务器,提供文件存储功能。Tus是开源的断点续传的框架,用于连接Minio并...

    本篇主要用来说明基于minio文件存储的断点续传及断点下载的解决方案

    1.断点续传

    断点续传功能采用Tus+Minio结构,其中Minio作为文件存储服务器,提供文件存储功能。Tus是开源的断点续传的框架,用于连接Minio并提供统一的接口供客户端连接。服务端由go编写,客户端提供多种语言,如js、java、android

    tus及minio, docker-compose.yml文件:

    version: '3.3'
    services:
      minio-server:
        image: minio/minio
        container_name: minio-server
        volumes:
          - ./data:/data
        ports:
          - 9000:9000
        environment:
          MINIO_ACCESS_KEY: admin
          MINIO_SECRET_KEY: 123456
        command: server /data
        restart: always
      tus-server:
        image: tusio/tusd
        container_name: tus-server
        ports:
          - 1080:1080
        privileged: true
        environment:
          AWS_ACCESS_KEY_ID: admin
          AWS_SECRET_ACCESS_KEY: 123456
          AWS_REGION: us-east-1
        command:
          ["--s3-bucket","bucketname","--s3-endpoint","http://minio1:9000","--base-path","/files/"]
    
    networks:
      default:
        driver: bridge

    前端Uppy.js可支持上传, index.html

    <!doctype html>
    <html>
      <head>
        <meta charset="utf-8">
        <title>Uppy</title>
        <link href="https://transloadit.edgly.net/releases/uppy/v1.0.0/uppy.min.css" rel="stylesheet">
      </head>
      <body>
        <div id="drag-drop-area"></div>
    
        <script src="https://transloadit.edgly.net/releases/uppy/v1.0.0/uppy.min.js"></script>
        <script>
          var uppy = Uppy.Core()
            .use(Uppy.Dashboard, {
              inline: true,
              target: '#drag-drop-area'
            })
            .use(Uppy.Tus, {endpoint: 'http://localhost:1080/files/'})
    
          uppy.on('complete', (result) => {
            console.log('Upload complete! We’ve uploaded these files:', result.successful)
          })
        </script>
      </body>
    </html>

    浏览器打开index.html即可实现断点续传功能。

     2.断点下载功能

    断点下载功能可以根据Minio提供的原有接口实现该功能。minio提供文件状态查询接口,可根据bucketname 和objectname查询文件字节大小。minio的获取文件方法还提供了可根据字节数范围获取文件。由此可实现断点下载功能。

    如下为测试demo,使用go语言编写

    package main
    
    import (
       "fmt"
       "github.com/minio/minio-go"
       "os"
    )
    
    func NewMinIOClient()(client *minio.Client)  {
       ssl:=false
       client,err:=minio.New("127.0.0.1:9000","admin","123456",ssl)
       if err!=nil{
          panic(err)
       }
       return 
    }
    
    func main()  {
       client:=NewMinIOClient()
       objectName:="test.jpg"  //minio中已有的objectname
       bucketName:="bucketname" //minio中的bucketname
       
       //获取object 信息
       stat,err:=client.StatObject(bucketName,objectName,minio.StatObjectOptions{})
       if err!=nil{
          panic(err)
       }
       
       var start int64 //定义下载的起始位置
       
       //获取本地文件的状态
       localStat,err:=os.Stat(objectName)
       
       if err!=nil{
          //如果本地文件不存在,则从开始下载
          if os.IsNotExist(err){
             start=0
          }else {
             //若为其他错误
             panic(err)
          }
       }else {
          if localStat.Size()==stat.Size{
             fmt.Println("已下载完整文件,无需下载")
          }else if localStat.Size()<stat.Size{
             //若本地未下载完成,则将start赋值,继续下载
             start=localStat.Size()
          }else{
             fmt.Printf("文件大小错误")
             return
          }
       }
       
       //配置minio objectOption
       objectOptin:=minio.GetObjectOptions{}
       end:=stat.Size
       err=objectOptin.SetRange(start,end)
       if err!=nil{
          panic(err)
       }
       
       //从minio中获取object
       o,err:=client.GetObject(bucketName,objectName,objectOptin)
       if err!=nil{
          panic(err)
       }
       
       //将读到的文件流以追加的方式写入
       b:=make([]byte,end-start)
       _,err=o.Read(b)
       if err!=nil{
          panic(err)
       }
       
       file,err:=os.OpenFile(objectName,os.O_APPEND|os.O_WRONLY|os.O_CREATE,0644)
       defer file.Close()
       if _,err:=file.Write(b);err!=nil{
          fmt.Println(err)
       }
    }

     

    展开全文
  • 用 Java 实现断点续传 (HTTP),内容有: 断点续传的原理, Java 实现断点续传的关键几点, 断点续传内核的实现等。
  • 开源项目-minio-mc.zip

    2019-09-19 10:05:43
    开源项目-minio-mc.zip,基于go的amazon s3 cli
  • 我们都知道,MinIO 是一个基于Apache License v2.0开源协议的对象存储服务文件系统。...本节将说明如何将大文件续传minio文件服务器。 putObject(String bucketName, String objectName, InputStream stream,

    我们都知道,MinIO 是一个基于Apache License v2.0开源协议的对象存储服务文件系统。它基于云原生文件系统生态,兼容亚马逊S3云存储服务接口,非常适合于存储大容量非结构化的数据。例如:视频、图片、数据文件、日志文件、备份数据和容器/虚拟机镜像等,而一个对象文件可以是任意大小,文件大小从几kb到最大5T不等。本节将说明如何将大文件续传到minio文件服务器。

    putObject(String bucketName, String objectName, InputStream stream, long size, String contentType, SecretKey key)
    public void putObject(String bucketName, String objectName, InputStream stream, long size, String contentType, SecretKey key)
    

    通过文件路径拿到流的数据,使用随机生成的content key进行加密,并上传到已指定的存储桶中。同时将加密后的content key和iv做为加密对象有header也上传到存储桶中。content key使用传入到该方法的master key进行加密。如果上传对象大于5MB,客户端会自动进行multi part上传。

    参数说明
    参数描述返回参数
    示例

    `引入相关依赖`
    <dependency>
      <groupId>io.minio</groupId>
      <artifactId>minio</artifactId>
      <version>7.1.4</version>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot</artifactId>
    </dependency>
    
    `application.yml文件配置`
    minio:
      access-key: minio
      security-key: minio
      endpoint: http://127.0.0.1:9000
      bucket-name: bucketMinio
      path-name: pathDir/
    
    @ConfigurationProperties(prefix = "minio")
    @Component
    @Data
    public class MinioProperties {
    
        private String accessKey;
    
        private String securityKey;
    
        private String endpoint;
    
        private String bucketName;
    
        private String pathName;
    }
    
    `实战代码`
    public class BreakpointContinue{
        /*** file part size*/
        private static final int FILE_PART_SIZE = 1024 * 1024 * 10;
        private final MinioProperties properties;
        private MinioClient minioClient;
    
        public MinioLoaderTask(MinioProperties properties) {
            this.properties = properties;
            minioClient = MinioClient.builder()
                    .credentials(properties.getAccessKey(), properties.getSecurityKey())
                    .endpoint(properties.getEndpoint())
                    .build();
        }
        
        /**
         * 文件上传
         * @param dataFilePath 文件路径
         */
        public void breakpointUpload(String dataFilePath) {
            try {
                boolean isExist = minioClient.bucketExists(BucketExistsArgs.builder().bucket(properties.getBucketName()).build());
                if (!isExist) {
                    throw new IllegalArgumentException("bucket is not exist :" + properties.getBucketName());
                }
                long objectSize = Files.size(Paths.get(dataFilePath));
                String objectName = properties.getPathName() + getFileName(dataFilePath);
                try (InputStream in = new FileInputStream(dataFilePath)) {
                    minioClient.putObject(PutObjectArgs.builder()
                            .bucket(properties.getBucketName())
                            .object(objectName)
                            .stream(in, objectSize, FILE_PART_SIZE)
                            .build());
                }
            } catch (Exception e) {
                log.error("上传文件异常", e);
            }
        }
    
        private static String getFileName(String filePath) {
            int lastIndex = filePath.lastIndexOf(File.separator);
            if (lastIndex > -1) {
                return filePath.substring(lastIndex + 1);
            }
            return null;
        }
    }
    
    展开全文
  • minio api有一个生成上传url的api,这个api可以指定接下来要上传文件的文件名,也就是说,在上步骤,我们只要保证上传的分片文件是有规则的,那么我们就可以很轻松的获取到 举个例子:上传文件的大小为10

    初步流程:
    选择上传文件 -> 提取md5 -> 请求后端校验此md5的文件是否已经上传过 -> 如果有上传就返回信息告诉前端上传完成(秒传) -> 如果没有则根据此md5获取已上传的分片有哪些,未上传的分片有多少个就返回多少个上传url

    如何获取已上传的分片有哪些呢?
    minio api有一个生成上传url的api,这个api可以指定接下来要上传文件的文件名,也就是说,在上传步骤,我们只要保证上传的分片文件是有规则的,那么我们就可以很轻松的获取到

    举个例子:上传文件的大小为10m,分片2个,md5为 asdfghjkl,则我们生成2个上传url,每个url指定的文件名为 md5/分片序号.chunk(分片文件要不要文件后缀都可以) 的格式,也就是 asdfghjkl/1.chunk;asdfghjkl/2.chunk

    所有分片文件上传完成后,通过 listObjects 获取到 asdfghjkl前缀开头的所有文件,即是所有分片文件的path,最后合并文件即可

    为什么不所有步骤都采用前端直连Minio?毕竟官方的sdk也提供了前端的示例
    这样做会直接暴露有关于minio的敏感信息,并且不管怎样,始终也需要后端去记录最终文件上传完成后的信息,所以一些敏感的操作,还是由后端程序来协助

    这个流程的好处:

    省掉每个分片的md5计算
    省掉每上传一个分片文件就请求后端记录一次分片信息
    省掉每个分片的数据库存储,合并文件后只需要删除分片文件,不需要再删除数据库数据
    可以并发上传
    文件上传直连于minio服务,不经过后端程序
    分片文件更方便管理,比如分片文件上传到一个B桶里,合

    展开全文
  • minio api 在对于大于5m的文件,自动采用了分片上传。 但它的分片上传我们无法得知上传的分片后的序号,也就是说,每上传一个分片,我们都需要自己去记录已上传分片的序号。 这将导致一个文件分片5个,那么同样还...
  • 使用webUploader实现大文件的断点续传,其中redis记录文件的上传信息,包括基本信息、历史文件夹名称和进度信息等。
  • https://blog.csdn.net/u012319157/article/details/79111491 转载于:https://www.cnblogs.com/feifeicui/p/11079692.html
  • 曾经上传一部分:前端在上每个模块之前,先请求后台,判断此模块是否已经上传过,如果已经上传过,则不需要再上传,否则上传。 注:启动以后直接访问http://localhost:9002/demo/largeUpload/open,如果本地运行...
  • springboot断点续传

    2020-12-17 15:36:45
    解决网络等外部因素导致大文件上传中途失败而引起的客户不友好的问题,分片断点上传大文件,springboot的框架
  • minio实现大文件分片上传+断点续传+预览 只提供后端java代码 思路: 前端分片 校验文件md5是否已经存在 --不存在创建临时桶存分片 校验分块是否已经上传 分块上传 合并分块 校验合成后md5是否相同 代码gitee: ...
  • 大文件上传的一个小例子,springboot框架集成mybatis,数据库是mysql。采用分片上传,理论支持无限大小,实际测试过1.5G左右大小的文件。
  • webuploader断点续传

    2020-03-07 00:12:19
    webuploader断点续传,webuploader断点续传webuploader断点续传webuploader断点续传
  • Golang实现断点续传

    2017-12-25 23:46:00
    HTTP Range 请求 ...Partial Requests在使用比较大的网络媒体文件或者在下载文件时提供暂停和恢复功能时很有用。 这也是下载时实现HTTP断点续传的一个关键。 HTTP 206 (Partial Content) 如果服务器能返回H...
  • 前端Excel大文件file slice分片,md5校验文件完整性并作文件标识记录写入数据库,支持断点续传。文件上传完毕后,使用EasyExcel读取文件流,处理Excel数据写入数据库中,可处理百万级数据。项目完整,连接数据库即可...
  • 注意,本文所说的断点续传特指 HTTP 协议中的断点续传。本文主要聊聊思路和关键代码,更多细节请参考本文附带的 demo。 工作原理 HTTP 协议中定义了一些请求/响应头,通过组合使用这些头信息。我们可以在一次 HTTP ...
  • python实现断点续传下载文件

    万次阅读 2015-08-30 16:16:18
    要实现断点续传,get()的stream参数要设为True在远程打开的是一个流,而headers里放的是续传的一些参数,这里的 headers = {'Range': 'bytes=%d-' % local_file_size} 就是获得本地文件的大小作为续传的起点...
  • minio_test.zip

    2019-08-31 18:00:46
    minio获取上传进度, golang语言关于接口的实现说明,golang语言的结构体的成员函数关于(this type)和(this *type)的区别
  • 对象存储服务minio

    2018-07-25 15:55:00
    wget https://dl.minio.io/server/minio/release/linux-amd64/minio chmod +x minio ./minio server /mnt/data Minio快速入门 Minio 是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云...
  • SpringBoot通过Minio实现大文件分片上传

    千次阅读 热门讨论 2021-02-23 17:18:25
    最近开发功能需要大文件上传,正常会在业务代码中封装一层minio的上传,为了避免中转,实现了minio的方式。实现过程中也确实碰到了不少坑,只能查询文档,本着开箱即用,简单方便的原则,java版本的Minio sdk...
  • 开源项目-minio-minio-go.zip,minio go library,用于与amazon s3兼容的云存储。
  • Minio是什么 官方说明: MinIO 是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服务接口,非常适合于存储大容量非结构化的数据,例如图片、视频、日志文件、备份数据和容器/虚拟机镜像...
  • springboot+jpa+vue实现大文件断点续传

    千次阅读 2020-04-05 17:58:27
    断点续传导入sql,如果里面有数据清除即可创建springboot项目,并导入依赖创建实体类定义dao接口和业务层代码控制层controllerFileUtils工具类配置文件application.yml跨域问题 导入sql,如果里面有数据清除即可 /* ...

空空如也

空空如也

1 2 3 4 5
收藏数 98
精华内容 39
关键字:

minio断点续传