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

简介

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

之后等待下载
下载完成后，会显示该页面

5、检查是否启动成功

使用docker ps

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

6、访问连接

访问 ip:9001 即可

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

登录后页面

遇到问题

1、密码至少要8位

minio使用创建bucket，上传图片，并访问 1、点击创建

2、创建bucket

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

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

3、测试上传文件

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

之后我们点击进入图片

4、生成链接并访问临时链接

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

永久链接

1、开放权限

springboot整合minio 步骤 1、导入依赖

 
            io.minio
            minio
            8.0.0

2、添加配置

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

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;


@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();
    }

    
    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);
        }
    }

    
    public static String getBasisUrl() {
        return endpoint + SEPARATOR + bucketName + SEPARATOR;
    }

    

    
    private static void createBucket(String bucketName) throws Exception {
        if (!bucketExists(bucketName)) {
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
        }
    }

    
    public static boolean bucketExists(String bucketName) throws Exception {
        return minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
    }


    
    public static String getBucketPolicy(String bucketName) throws Exception {
        String bucketPolicy = minioClient
                                .getBucketPolicy(
                                        GetBucketPolicyArgs
                                                .builder()
                                                .bucket(bucketName)
                                                .build()
                                );
        return bucketPolicy;
    }


    
    public static List getAllBuckets() throws Exception {
        return minioClient.listBuckets();
    }

    
    public static Optional getBucket(String bucketName) throws Exception {
        return getAllBuckets().stream().filter(b -> b.name().equals(bucketName)).findFirst();
    }

    
    public static void removeBucket(String bucketName) throws Exception {
        minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
    }

    


    

    
    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;
    }

    
    public static boolean isFolderExist(String bucketName, String objectName) {
        boolean exist = false;
        try {
            Iterable> results = minioClient.listObjects(
                    ListObjectsArgs.builder().bucket(bucketName).prefix(objectName).recursive(false).build());
            for (Result result : results) {
                Item item = result.get();
                if (item.isDir() && objectName.equals(item.objectName())) {
                    exist = true;
                }
            }
        } catch (Exception e) {
            exist = false;
        }
        return exist;
    }

    
    public static List getAllObjectsByPrefix(String bucketName,
                                                   String prefix,
                                                   boolean recursive) throws Exception {
        List list = new ArrayList<>();
        Iterable> objectsIterator = minioClient.listObjects(
                ListObjectsArgs.builder().bucket(bucketName).prefix(prefix).recursive(recursive).build());
        if (objectsIterator != null) {
            for (Result o : objectsIterator) {
                Item item = o.get();
                list.add(item);
            }
        }
        return list;
    }

    
    public static InputStream getObject(String bucketName, String objectName) throws Exception {
        return minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(objectName).build());
    }

    
    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());
    }

    
    public static Iterable> listObjects(String bucketName, String prefix,
                                                     boolean recursive) {
        return minioClient.listObjects(
                ListObjectsArgs.builder()
                        .bucket(bucketName)
                        .prefix(prefix)
                        .recursive(recursive)
                        .build());
    }

    
    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());
    }

    
    public static ObjectWriteResponse uploadFile(String bucketName, String objectName,
                                                String fileName) throws Exception {
        return minioClient.uploadObject(
                UploadObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .filename(fileName)
                        .build());
    }

    
    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());
    }

    
    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());
    }

    
    public static String getFileStatusInfo(String bucketName, String objectName) throws Exception {
        return minioClient.statObject(
                StatObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .build()).toString();
    }

    
    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());
    }

    
    public static void removeFile(String bucketName, String objectName) throws Exception {
        minioClient.removeObject(
                RemoveObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .build());
    }

    
    public static void removeFiles(String bucketName, List keys) {
        List objects = new LinkedList<>();
        keys.forEach(s -> {
            objects.add(new DeleteObject(s));
            try {
                removeFile(bucketName, s);
            } catch (Exception e) {
                log.error("批量删除失败！error:{}",e);
            }
        });
    }

    
    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);
    }

    
    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);
    }

    
    public static String getUtf8ByURLDecoder(String str) throws UnsupportedEncodingException {
        String url = str.replaceAll("%(?![0-9a-fA-F]{2})", "%25");
        return URLDecoder.decode(url, "UTF-8");
    }

    

}

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调用接口进行测试

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

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

原因：

端口用错了，应该使用的是9000的，而不是9001,9001是界面的端口，9000才是api的端口

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

原因：linux服务器时区的问题。
解决方式：
1、检查系统时间和硬件时间

2、如果不同的话，则需要同步
a.安装 yum -y install ntp ntpdate
b.设置系统时间与网络时间同步
ntpdate cn.pool.ntp.org
c.将系统时间写入硬件时间hwclock --systohc

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

Java相关栏目本月热门文章