【对象存储】minio的安装、使用及springboot集成

已于 2022-07-26 17:49:22 修改
阅读量2.5k 收藏 4
点赞数
CC 4.0 BY-SA版权
分类专栏： 对象存储 springboot系列 文章标签： spring boot
于 2022-07-25 22:19:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Think_and_work/article/details/125984608

简介

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

安装

docker-compose安装

步骤

1、创建minio文件夹

mkdir minio

2、创建data config文件夹

进入minio文件夹中cd minio/
创建data和config文件夹
mkdir data
mkdir config

3、在minio文件夹中创建docker-compose.yaml文件
version: "3"

services:
  minio:
    image: minio/minio:RELEASE.2022-03-22T02-05-10Z
    # 将data config文件夹挂在到当前目录的data config
    volumes:
      - "./data:/data"
      - "./config:/root/.minio"
    # 账号密码配置
    environment:
      - MINIO_ACCESS_KEY=admin
      - MINIO_SECRET_KEY=123456
    # 端口配置  
    ports:
      - "9000:9000"
      - "9001:9001"
    command: server /data --console-address ":9001"
    restart: always

复制的时候，可以复制下面这个文件，因为上面文件使用注释的，所以可能会导致格式混乱

version: "3"

services:
  minio:
    image: minio/minio:RELEASE.2022-03-22T02-05-10Z
    volumes:
      - "./data:/data"
      - "./config:/root/.minio"
    environment:
      - MINIO_ACCESS_KEY=admin
      - MINIO_SECRET_KEY=12345678
    ports:
      - "9000:9000"
      - "9001:9001"
    command: server /data --console-address ":9001"
    restart: always
4、启动

docker-compose up -d
image.png
之后等待下载
下载完成后，会显示该页面
image.png

5、检查是否启动成功

使用docker ps
image.png
如果是up则代表ok了，如果不是的话，则在minio文件夹内，执行docker-compose logs -f查看日志

6、访问连接

访问 ip:9001 即可
image.png

访问成功后的页面
之后使用docker-compose.yaml的配置文件的密码登录
image.png

登录后页面
image.png

遇到问题

1、密码至少要8位
image.png

minio使用

创建bucket，上传图片，并访问

1、点击创建

image.png

2、创建bucket

image.png
目前我们这里的配置都选择默认，也就是不配置

Versioning：多版本控制
Object Locking：对象锁定
Quota：限制数量
创建后，桶的文件是空的，我们可以尝试进行上传
image.png

3、测试上传文件

image.png
image.png

上传之后，就会生成一条数据了
image.png

之后我们点击进入图片
image.png

4、生成链接并访问

临时链接

image.png
之后点击临时链接访问即可
但是需要注意，复制出来的链接可能会无法访问，这个原因暂时也不是特别清楚，所以我们采用永久链接进行处理

永久链接

1、开放权限
image.png

image.png
image.png
image.png

springboot整合minio

步骤

1、导入依赖

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

2、添加配置

可以在yaml中配置参数，当然，如果有多环境的话，需要进行多环境配置
image.png

minio:
  endpoint: http://192.168.56.10:9000
  accessKey: admin
  secretKey: 12345678
  bucketName: walkertest

或者如果你觉得麻烦，想直接写死在代码中也是可以的，但是不是很建议那样做

3、编写配置类和工具类

配置类
// 使用配置类注解
@Configuration
public class MinioConfig {

//    获取yaml文件中的数据
    @Value("${minio.endpoint}")
    private String endpoint;
    @Value("${minio.accessKey}")
    private String accessKey;
    @Value("${minio.secretKey}")
    private String secretKey;
    @Value("${minio.bucketName}")
    private String bucketName;


//    注入容器中
    @Bean
    public MinIOUtils createMinioClient(){
        return new MinIOUtils(endpoint, bucketName, accessKey, secretKey);
    }

}
工具类
package com.walker.springbootdemo.util;

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.stereotype.Component;
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
@Component
public class MinIOUtils {

    private static MinioClient minioClient;

    private static String endpoint;
    private static String bucketName;
    private static String accessKey;
    private static String secretKey;


    private static final String SEPARATOR = "/";

    public MinIOUtils() {
    }

    public MinIOUtils(String endpoint, String bucketName, String accessKey, String secretKey) {
        MinIOUtils.endpoint = endpoint;
        MinIOUtils.bucketName = bucketName;
        MinIOUtils.accessKey = accessKey;
        MinIOUtils.secretKey = secretKey;
        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 static String getBasisUrl() {
        return endpoint + SEPARATOR + bucketName + SEPARATOR;
    }

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

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

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


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


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

    /**
     * 根据bucketName获取其相关信息
     * @param bucketName
     * @return
     * @throws Exception
     */
    public static 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 static 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 static 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 static 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 static 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 static 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 static 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 static 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 static 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 static 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 static 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 static 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 static 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 static void removeFile(String bucketName, String objectName) throws Exception {
        minioClient.removeObject(
                RemoveObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .build());
    }

    /**
     * 批量删除文件
     * @param bucketName 存储桶
     * @param keys 需要删除的文件列表
     * @return
     */
    public static 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 static 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 static 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 static 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  ******************************/

}

4、上传文件测试代码编写

package com.walker.springbootdemo.controller;

import com.walker.springbootdemo.common.config.MinioConfig;
import com.walker.springbootdemo.util.MinIOUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

@RestController
@RequestMapping("/minio")
public class MinioController {

//    注入配置类
    @Autowired
    private MinioConfig minioConfig;


//    编写上传接口
    @PostMapping("/upload")
    public String upload(MultipartFile file) throws Exception {


        MinIOUtils.uploadFile(minioConfig.getBucketName(),file.getOriginalFilename(),file.getInputStream());
        String format="%s/%s/%s";

//        返回的访问连接
        String url = String.format(format, minioConfig.getEndpoint(), minioConfig.getBucketName(), file.getOriginalFilename());
        return url;
    }
}

5、测试

使用Postman调用接口进行测试
image.png

之后访问返回的地址，便可以获取图片

问题

1、io.minio.errors.InvalidResponseException: Non-XML response from server. Response code: 403, Content-Type: text/xml; charset=utf-8, body: <?xml version="1.0" encoding="UTF-8"?>
AccessDenied S3 API Request made to Console port. S3 Requests should be sent to API port. 0

原因：
image.png
端口用错了，应该使用的是9000的，而不是9001,9001是界面的端口，9000才是api的端口

2、The difference between the request time and the server’s time is too large.

原因：linux服务器时区的问题。
解决方式：
1、检查系统时间和硬件时间
image.png
2、如果不同的话，则需要同步
a.安装 yum -y install ntp ntpdate
b.设置系统时间与网络时间同步
ntpdate cn.pool.ntp.org
c.将系统时间写入硬件时间hwclock --systohc

SpringBoot集成Minio（简单使用）
zy_javaAndweb的博客
08-01 1205
分布式文件存储minio
SpringBoot项目集成MinIO
m0_54850786的博客
01-01 1046
最近在学习MinIO，所以想让自己的SpringBoot项目集成MinIO,在网上查阅资料，并进行操作的过程中遇到一些问题，所以想把自己遇到的坑和完成步骤记录下来供自己和各位查阅。
spring boot 中使用minio
太子的博客
08-23 5755
spring boot 中使用minio
minio 报错Access Denied
最新发布
u014572906的博客
05-23 534
出现Access Denied错误，时我们手动创建buckets时，access policy默认时private,需要修改为public。minio安装起来非常简单。
springboot 使用 minio
qq_43842093的博客
12-11 1702
yml 配置 ====================== ↓↓↓↓↓↓ MinIO文件服务器 ↓↓↓↓↓↓ ====================== minio: url: http://114.67.110.190:9001 accessKey: minioadmin secretKey: minioadmin bucketName: zpf maven: io.minio minio 7.1.0 属性文件： pac
Spring Boot使用MinIO
weixin_42502300的博客
05-27 333
1、pom文件 <!-- MinIO 客户端 --> <dependency> <groupId>io.minio</groupId> <artifactId>minio</artifactId> <version>8.2.2</version> </dependency> 2、minio
SpringBoot-集成Minio
孟孟的博客
10-24 9591
Minio 是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几kb到最大5T不等。Minio是一个非常轻量的服务,可以很简单的和其他应用的结合，类似 NodeJS, Redis 或者 MySQL。
minio 安装步骤以及springboot 如何集成minio
08-07
### SpringBoot集成MinIO 1. **添加依赖**: 在SpringBoot的`pom.xml`或`build.gradle`文件中，添加MinIO的客户端库依赖。如果是Maven，添加如下依赖： ```xml <groupId>io.minio <artifactId>minio <version>...
MinIO【部署 01】MinIO安装及SpringBoot集成简单测试_minio arm架构安装
2401_85599444的博客
06-24 483
【代码】MinIO【部署 01】MinIO安装及SpringBoot集成简单测试_minio arm架构安装。
Windows搭建本地对象存储服务MinIO并且使用springboot整合
weixin_48965172的博客
07-05 1207
准备一个空的文件夹，用来存放minio相关的内容；这里是在D盘创建一个minio的文件夹；后续所有跟MinIO相关的内容，都是基于此文件夹示例【D:\minio】将这个应用程序移入提前准备的文件夹中【D:\minio\bin】不要双击运行！！！不要双击运行！！！不要双击运行！！！打开cmd窗口，定位到【D:\minio\bin】文件夹中，输入下方命令，启动MinIO服务，不需要进行其他操作；
springboot使用minio进行文件管理
weixin_54497063的博客
01-06 1189
springboot+docker desktop使用minio进行文件管理，记录一下。这里我用docker desktop去安装minio，如果本地已经装好minio的话可以跳过前面的步骤。安装docker的步骤我就省略了。
springboot项目中使用minio进行对象存储
栉风的博客
05-05 5681
springboot项目中引入minio对象存储
在Spring Boot应用中配置和使用MinIO
weixin_36942614的博客
08-20 262
要在Spring Boot项目中使用MinIO作为对象存储服务，可以使用MinIO的Java SDK来与MinIO进行交互。以下是如何在Spring Boot应用中配置和使用MinIO的详细步骤：1. 添加MinIO依赖首先，你需要在项目中添加MinIO的Java SDK依赖。如果使用的是Maven，添加以下依赖到pom....
【Minio】SpringBoot 整合 Minio（案例代码拿来即用）
杜小舟的博客
03-27 1140
本篇文章只讲解MinIo的基本使用，下面有一些案例代码拿来即用，不过要注意桶和对象这两个概念，对桶和对象这两个概念下面有讲解。
SpringBoot整合Minio
liyh722的博客
08-07 3614
SpringBoot整合Minio
SpringBoot整合MinIO
w1245247503的博客
02-27 1315
MinIO的安装和运行以及SpringBoot整合MinIO
SpringBoot整合MinIO快速入门：实现分布式文件存储与管理
weixin_42593797的博客
04-06 1683
‌MinIO‌是一款高性能的分布式对象存储服务，完全兼容Amazon S3协议。它轻量级、易部署，适合存储非结构化数据（图片、视频、日志等），广泛应用于微服务架构中的文件存储场景。通过本文，我们完成了SpringBoot与MinIO的整合，实现了文件上传、下载等核心功能。MinIO作为轻量级对象存储方案，可轻松应对中小型项目的文件存储需求。后续可结合‌CDN加速‌、‌分片上传‌等功能进一步优化用户体验。
SpringBoot整合minio服务（超详细）
热门推荐
yueyue763184的博客
06-10 1万+
创建一个名为public的存储桶（名字可自定义），上传文件。在application.yml文件中编写相关配置。http://ip:9000/存储桶名/文件名。开发中上传接口用得较多，其他接口可自行测试。可以将存储桶的访问权限设置为public.# npm下载element-ui。// 引入ElementUI。
一步搞定Minio安装与SpringBoot集成教程
资源摘要信息:"本文主要介绍如何在Spring Boot项目中集成MinIO对象存储服务，包括MinIO的基本安装步骤和在Spring Boot中的使用方法。MinIO是一个高性能的分布式对象存储服务，可以用来处理大量非结构化的数据，如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

WalkerShen

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值