minio开源的对象存储服务器安装及使用

1.minio的介绍

MinIO是一个开源的对象存储服务器，设计用于实现高性能、可扩展的云存储。它兼容Amazon S3云存储服务的API，因此可以与现有的S3兼容应用程序进行集成。
MinIO可以部署在本地服务器、私有云环境或公共云上，如AWS、Azure、Google Cloud等。它通过将数据分散在多个独立节点上实现高可用性和容错性，同时提供强大的分布式对象存储能力。
使用MinIO，你可以通过简单的RESTful API/API对象将数据上传、存储和检索到MinIO服务器。MinIO还提供了许多功能，如数据加密、存储桶生命周期管理、事件通知、访问控制等，以满足各种存储需求。
由于MinIO的可扩展性和高性能，它被广泛用于构建各种应用程序，如数据湖、备份和恢复、文档存储、图像和视频存储等。它还是云原生生态系统中的一部分，可以与Kubernetes、Docker等常用工具无缝集成。
总而言之，MinIO是一个快速、可扩展和开源的对象存储服务器，为开发人员和组织提供了灵活、可靠的数据存储解决方案

2.安装docker版minio

1.拉取docker镜像

sudo docker pull minio/minio
1

2.创建映射文件

mkdir -p /docker/app/minio/data
mkdir -p /docker/app/minio/config
1
2

3.启动

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

这个命令是用来在 Docker 中运行 MinIO 容器的。下面是各个参数的说明：
● -p 9000:9000 -p 9090:9090 ：将容器的 9000 端口映射到主机的 9000 端口，将容器的 9090 端口映射到主机的 9090 端口。
● --name minio：给容器取一个名称为 “minio”。
● -d：以后台模式运行容器。
● --restart=always：当容器退出时，总是重启容器。
● -e "MINIO_ACCESS_KEY=minioadmin" -e "MINIO_SECRET_KEY=minioadmin"：设置环境变量，指定 MinIO 的访问密钥和密钥。
● -v /docker/app/minio/data:/data：将主机上 /docker/app/minio/data 目录挂载到容器的 /data 目录，用于持久化存储 MinIO 数据。
● -v /docker/app/minio/config:/root/.minio：将主机上 /docker/app/minio/config 目录挂载到容器的 /root/.minio 目录，用于持久化存储 MinIO 配置文件。
● minio/minio：使用 MinIO 官方提供的镜像。
● server /data：运行容器时执行的命令，启动 MinIO 服务器并指定数据目录为 /data。
● --console-address ":9090"：设置 MinIO 控制台的地址为 :9090，即容器的 9090 端口。
● -address ":9000"：设置 MinIO 服务器的监听地址为 :9000，即容器的 9000 端口。

PS:这个命令会创建一个名为 “minio” 的容器，该容器运行 MinIO 对象存储服务器，并将数据存储在本地的指定目录中。你可以使用 http://localhost:9000 访问 MinIO 服务器，并使用指定的访问密钥和密钥进行身份验证。另外，你也可以使用 http://localhost:9090 访问 MinIO 控制台进行管理操作。

4.验证

3.开发中使用minio

maven依赖

    <!--引入MINIO依赖-->
        <dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <version>8.3.0</version>
        </dependency>
        <dependency>
            <groupId>me.tongfei</groupId>
            <artifactId>progressbar</artifactId>
            <version>0.5.3</version>
        </dependency>
        <dependency>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>okhttp</artifactId>
            <version>4.8.1</version>
        </dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

1.工具类准备

minio核心配置类

/**
 * minio核心配置类
 * 通过注入 MinIO 服务器的相关配置信息，得到 MinioClient 对象，我们上传文件依赖此对象
 */
@Configuration
public class MinioConfig {

    @Autowired
    private MinioProperties prop;

    /**
     * 获取 MinioClient
     *
     * @return MinioClient
     */
    @Bean
    public MinioClient minioClient() {
        return MinioClient.builder().endpoint(prop.getEndpoint()).credentials(prop.getAccessKey(), prop.getSecretKwy())
            .build();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

minio配置类:

/**
 * minio 属性值
 */
@Data
@Component
@ConfigurationProperties(prefix = "minio")
public class MinioProperties {
    /** 连接url */
    private String endpoint;
    /** 公钥 */
    private String accessKey;
    /** 私钥 */
    private String secretKwy;
    /** 桶名 */
    private String bucketName;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

minio工具类

@Component
public class MinioUtils {
    @Autowired
    private MinioClient minioClient;
    @Autowired
    private MinioProperties minioProperties;

    /**
     * 创建桶
     *
     * @param bucketName 桶名称
     */
    @SneakyThrows
    public void createBucket(String bucketName) {
        boolean found = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
        if (!found) {
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).region("cn-beijing").build());
        }
    }

    /**
     * 删除桶
     *
     * @param bucketName 桶名称
     */
    @SneakyThrows
    public void removeBucket(String bucketName) {
        minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
    }

    /**
     * 上传文件
     *
     * @param fileName 文件名
     * @param stream 流
     * @param fileSize 文件大小
     * @param type 文件类型
     * @throws Exception
     */
    public void uploadFile(String bucketName, String fileName, InputStream stream, Long fileSize, String type)
    throws Exception {
        minioClient.putObject(PutObjectArgs.builder().bucket(bucketName).object(fileName).stream(stream, fileSize, -1)
            .contentType(type).build());
    }

    /**
     * 判断文件夹是否存在
     *
     * @param bucketName 桶名称
     * @param prefix 文件夹名字
     * @return
     */
    @SneakyThrows
    public Boolean folderExists(String bucketName, String prefix) {
        Iterable<Result<Item>> results = minioClient.listObjects(ListObjectsArgs.builder().bucket(bucketName).prefix(
            prefix).recursive(false).build());
        for (Result<Item> result : results) {
            Item item = result.get();
            if (item.isDir()) {
                return true;
            }
        }
        return false;
    }

    /**
     * 创建文件夹
     *
     * @param bucketName 桶名称
     * @param path 路径
     */
    @SneakyThrows
    public void createFolder(String bucketName, String path) {
        minioClient.putObject(PutObjectArgs.builder().bucket(bucketName).object(path)
            .stream(new ByteArrayInputStream(new byte[] {}), 0, -1).build());
    }

    /**
     * 获取文件在minio在服务器上的外链
     *
     * @param bucketName 桶名称
     * @param objectName 文件名
     * @return 可访问的URL
     * expiry(int duration, TimeUnit unit) 设置有效时间,这里是设置为URL的有效期为1天,即在一天以后国企.
     */
    @SneakyThrows
    public String getObjectUrl(String bucketName, String objectName) {
        return minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder().method(Method.GET).bucket(
            bucketName).object(objectName).expiry(1, TimeUnit.DAYS).build());
    }

    /**
     * 生成可访问的url
     *
     * @param filePath 文件路径
     * @return 可访问的文件, 过期时间1day
     * @author HuangLongFei
     * @since 2023/3/11
     */
    public String generateUrl(String filePath) {
        return getObjectUrl(minioProperties.getBucketName(), filePath);
    }

    /**
     * 批量删除文件
     *
     * @param filePathList 文件路径列表
     * @author HuangLongFei
     * @since 2023/7/17
     */
    public void deleteFile(List<String> filePathList) {
        if (CollectionUtils.isEmpty(filePathList)) {
            return;
        }
        // 构建要删除的文件列表
        List<DeleteObject> deleteFileList = new ArrayList<>();
        for (String filePath : filePathList) {
            deleteFileList.add(new DeleteObject(filePath));
        }
        try {
            // 批量删除文件
            RemoveObjectsArgs fileArgs = RemoveObjectsArgs.builder().bucket(minioProperties.getBucketName()).objects(
                deleteFileList).build();
            Iterable<Result<DeleteError>> fileDeleteResult = minioClient.removeObjects(fileArgs);
            // 注意这里必须迭代返回结果,因为removeObjects是惰性的
            for (Result<DeleteError> result : fileDeleteResult) {
                DeleteError deleteError = result.get();
            }
        } catch (Exception e) {
            throw new ProjectException(ExceptionEnum.MINIO_CALL_ERROR);
        }
    }
}

    /**
     * 获取minio中,某个bucket中所有的文件名
     */
    public List<String> getFileList(String bucketName) {
        // 根据bucketName,获取该桶下所有的文件信息
        Iterable<Result<Item>> results = minioClient.listObjects(ListObjectsArgs.builder().bucket(bucketName)
            .recursive(true).build());
        List<String> fileNameList = new ArrayList<>();
        for (Result<Item> result : results) {
            Item item;
            String fileName = null;
            try {
                item = result.get();
                fileName = item.objectName();
                fileNameList.add(fileName);
            } catch (Exception e) {
                log.error("call the minioClient.listObjects Error. result={} and message = {}", result, e);
            }
            // 获取文件的访问路径
            if (StringUtils.isNotBlank(fileName)) {
                String accessUrl = getObjectUrl(bucketName, fileName);
            }
        }
        return fileNameList;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

application.yml文件

## 配置minio的公钥和私钥
minio:
  bucket-name: 
  endpoint: 
  access-key: 
  secret-kwy: 
1
2
3
4
5
6

2.测试

@SpringBootTest
public class minioTest {
    @Autowired
    private MinioUtils minioUtils;
    @Autowired
    private MinioProperties minioProperties;
    private final static String BUCKET_NAME_TEST = "bucket-test";

    /***
     * 测试目的:创建一个bucket
     */
    @Test
    public void createBucket() {
        String bucketName = BUCKET_NAME_TEST;
        minioUtils.createBucket(bucketName);
        System.out.println("create " + bucketName + " success!");
    }

    /***
     * 测试目的:删除一个bucket
     */
    @Test
    public void removeBucket() {
        String bucketName = BUCKET_NAME_TEST;
        minioUtils.removeBucket(bucketName);
        System.out.println("remove " + bucketName + " success!");
    }

    /***
     * 测试目的:创建文件夹,并上传路径
     */
    @Test
    public void uploadFile() {
        String filePath = "E:/tempoary/2023-07-21_10-53-35.png";
        File file = new File(filePath);
        // 设置要上传的路径,例如 /test/2023/123.jpg
        filePath = "/test/2023/" + file.getName();
        try {
            FileInputStream fileInputStream = new FileInputStream(file);
            minioUtils.uploadFile(BUCKET_NAME_TEST, filePath, fileInputStream, file.length(), "image/jpeg");
            System.out.println("上传成功!,文件路径:" + filePath);
        } catch (Exception e) {
            System.out.println("上传失败");
            e.printStackTrace();
        }
    }

    /***
     * 测试目的:生成可访问的图片的URL
     */
    @Test
    public void getObjectUrl() {
        String filePath = "test/2023/2023-07-21_10-53-35.png";
        String url = minioUtils.getObjectUrl(BUCKET_NAME_TEST, filePath);
        System.out.println(url);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

---

2023-8-8 15:41:53：更新内容，新增加获取minio中某个bucket所有的文件名的方法