搭建自己的OSS文件存储系统--MinIO

一、MinIO

MinIO概览

简介：
        MinIO是一款高性能、可扩展的对象存储服务器，专为现代应用设计。它不仅提供了媲美Amazon S3的功能，还通过其轻量级架构和强大的安全措施，成为企业和开发者青睐的选择。

核心特点

• 卓越性能：MinIO在分布式环境下展现出色的高速数据传输能力，尤其适合处理大规模数据集。
• 无缝扩展：具备高度的可扩展性，能够根据业务需求在集群模式下轻松扩展，实现存储容量和处理能力的线性增长。
• S3兼容性：全面支持Amazon S3 API，使得MinIO可以作为S3的直接替代方案，无需修改即可集成到已有的S3兼容应用程序中。
• 轻量化设计：软件体态轻盈，便于部署和维护，降低了管理复杂度。
• 全方位安全：内置多种安全机制，包括数据加密和细粒度访问控制，保障数据的安全与完整。

应用场景

• 对象存储服务：适用于存储海量非结构化数据，如图像、视频和日志文件，为多媒体内容提供高效存储和访问。
• 私有云存储：作为企业级私有云存储解决方案，满足对数据隐私和安全性的严格要求。
• 数据湖建设：MinIO是构建数据湖的理想基础，能够存储并处理多模态数据，支持高级数据分析和机器学习任务。

二、服务搭建

docker单节点部署：

        拉取镜像：

docker pull minio/minio

        启动容器：

docker run -p 9000:9000 -p 9001:9001 \
 --name minio -d \
 -d --restart=always \
 -e "MINIO_ACCESS_KEY=minioadmin" \
 -e "MINIO_SECRET_KEY=minioadmin" \
 -v /etc/docker/minio/data:/data \
 -v /etc/docker/minio/config:/root/.minio \
 minio/minio server \
 /data --console-address ":9001" -address ":9000"

注意，要把核心目录挂载到本地，避免容器问题导致数据丢失；9001为console端口，9000为API端口。

启动后访问控制台：ip+port（9001），

账号密码为启动时 MINIO_ACCESS_KEY、MINIO_SECRET_KEY的参数。

三、Python链接操作。

        安装minio依赖：pip3 install -U minio

import os
from minio import Minio
from datetime import timedelta
 
class Client:
    def __init__(self, endpoint, access_key, secret_key, secure=False):
        self.client = Minio(endpoint=endpoint, access_key=access_key, secret_key=secret_key, secure=secure)
 
    def list_buckets(self):
        return self.client.list_buckets()
 
    def make_bucket(self, bucket_name):
        if not self.client.bucket_exists(bucket_name):
            return self.client.make_bucket(bucket_name=bucket_name)
        else:
            return f"Bucket {bucket_name} already exists"
    
    def upload_file(self, bucket_name, object_name, file_path):
        return self.client.fput_object(bucket_name=bucket_name, object_name=object_name, file_path=file_path)
    
    def share_file(self, bucket_name, object_name, expires=None):
        return self.client.presigned_get_object(bucket_name, object_name, expires=timedelta(days=expires))
 
 
if __name__ == "__main__":
    image_path = "/Users/Downloads/img"

    # 地址,用户名,密码
    user = Client("xxx.xx.xxx.xx:9000", "xxxxx", "xxxxx") 

    # 创建bucket
    user.make_bucket("d-wan")

    # bucket列表
    print(user.list_buckets()) 
    
    # 上传文件
    for item in os.listdir(image_path):
        print(user.upload_file('d-wan', f"test/{item}", f"{image_path}/{item}").object_name)
    
    # 为文件生成临时链接
    print(user.share_file("d-wan", "test/southeast.jpeg", 7)) 

注意端口为9000的api端口，否则会报错：

执行脚本后上传文件：

四、Spring boot整合MinIO

1.配置文件

minio.accessKey = minioadmin
minio.secretKey = minioadmin
minio.bucket = test
minio.ip = http://xxx.xx.xxx.xx:9001
minio.read = http://xxx.xx.xxx.xx:9000
minio.servlet.multipart.max-file-size = 200MB
minio.servlet.multipart.max-request-size = 200MB

2.config类

@Configuration
public class MinIOConfig {

    @Resource
    private MinIOProperties minIOProperties;

    @Bean
    public MinioClient buildMinioClient() {
        return MinioClient
                .builder()
                .credentials(minIOProperties.getAccessKey(), minIOProperties.getSecretKey())
                .endpoint(minIOProperties.getIp())
                .build();
    }


}

3.核心方法

@Component
public class MinIOFacadeImpl implements MinIOFacade {

    @Resource
    private MinIOProperties minIOProperties;
    @Resource
    private MinioClient minioClient;

    private final static String separator = "/"; //文件夹分隔符

    @Override
    public String uploadFile(String prefix, String filename, InputStream inputStream) {
        String filePath = builderFilePath(prefix, filename);
        try {
            PutObjectArgs putObjectArgs = PutObjectArgs.builder()
                    .object(filePath)
                    .bucket(minIOProperties.getBucket()).stream(inputStream, inputStream.available(), -1)
                    .build();
            minioClient.putObject(putObjectArgs);
            return separator + minIOProperties.getBucket() +
                    separator +
                    filePath;
        } catch (Exception ex) {
            throw new RuntimeException("上传文件失败");
        }
    }

    @Override
    public String getTemporaryURL(String pathUrl) {
        String key = pathUrl.replace(minIOProperties.getIp() + "/", "");
        int index = key.indexOf(separator);
        String bucket = key.substring(0, index);
        String filePath = key.substring(index + 1);
        GetPresignedObjectUrlArgs args = GetPresignedObjectUrlArgs.builder()
                .bucket(bucket)
                .object(filePath)
                .expiry(5, TimeUnit.MINUTES)
                .method(Method.GET)
                .build();
        try {
            return minioClient.getPresignedObjectUrl(args);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    @Override
    public void delete(String pathUrl) {
        String key = pathUrl.replace(minIOProperties.getIp() + "/", "");
        int index = key.indexOf(separator);
        String bucket = key.substring(0, index);
        String filePath = key.substring(index + 1);
        // 删除Objects
        RemoveObjectArgs removeObjectArgs = RemoveObjectArgs.builder().bucket(bucket).object(filePath).build();
        try {
            minioClient.removeObject(removeObjectArgs);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public byte[] downLoadFile(String pathUrl) {
        String key = pathUrl.replace(minIOProperties.getIp() + "/", "");
        int index = key.indexOf(separator);
        String bucket = key.substring(0, index);
        String filePath = key.substring(index + 1);
        InputStream inputStream = null;
        try {
            inputStream = minioClient.getObject(GetObjectArgs.builder().bucket(minIOProperties.getBucket()).object(filePath).build());
        } catch (Exception e) {
            e.printStackTrace();
        }
        //字节数组输出流
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        byte[] buff = new byte[100];
        int rc = 0;
        while (true) {
            try {
                if (inputStream != null && !((rc = inputStream.read(buff, 0, 100)) > 0)) break;
            } catch (IOException e) {
                e.printStackTrace();
            }
            byteArrayOutputStream.write(buff, 0, rc);
        }
        return byteArrayOutputStream.toByteArray();
    }

    /**
     * 构建文件的绝对路径
     */
    public String builderFilePath(String dirPath, String filename) {
        StringBuilder stringBuilder = new StringBuilder(50);
        if (!StringUtils.isEmpty(dirPath)) {
            stringBuilder.append(dirPath).append(separator);
        }
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String todayStr = sdf.format(new Date());
        stringBuilder.append(todayStr).append(separator);
        stringBuilder.append(filename);
        return stringBuilder.toString();
    }
}