Docker安装MinIO

一、什么是MinIO？

为什么选择MinIO?

1、MinIO 是在 Apache License v2.0 下发布的对象存储服务器。 它与 Amazon S3 云存储服务兼容。 它最适合存储非结构化数据，如照片，视频，日志文件，备份和容器/ VM 映像。 对象的巨细可以从几 KB 到最大 5TB。
2、MinIO 服务器充足轻，可以与应用程序堆栈捆绑在一起，类似于 NodeJS，Redis 和 MySQL
3 一种高性能的分布式对象存储服务器，用于大型数据基础设施。它是机器学习和其他大数据工作负载下Hadoop HDFS 的理想 s3 兼容替代品
MinIO特点
   1、Minio 有精良的存储机制
2、Minio 有很好纠删码的算法与擦除编码算法
3、拥有RS code 编码数据恢复原理
4、公司做强做大时，数据的拥有重要性，对数据管理与大数据分析做准备。
5、搭建本身的一套文件系统服务,对文件数据进行安全掩护。
6、拥有本身的平台，不限于其他方限定。
  什么是纠删码？

   Minio利用纠删码技术来掩护数据，它是一种恢复丢失和破坏数据的数学算法，它将数据分块冗余的分散存储在各各节点的磁盘上，全部的可用磁盘组成一个聚集，上图由8块硬盘组成一个聚集，当上传一个文件时会通过纠删码算法计算对文件进行分块存储，除了将文件本身分成4个数据块，还会生成4个校验块，数据块和校验块会分散的存储在这8块硬盘上。利用纠删码的利益是即便丢失一半数目（N/2）的硬盘，仍旧可以恢复数据。 好比上边聚集中有4个以内的硬盘损害仍可包管数据恢复，不影响上传和下载，如果多于一半的硬盘坏了则无法恢复。
  二、Docker安装MinIO

1. 拉取镜像

1. docker pull minio/minio

复制代码

2. 查看镜像

1. docker images

复制代码

3. 创建MinIO的挂载目录
【/home/soft/minio/config】配置文件目录
【/home/soft/minio/data】存储文件的目录

1. mkdir -p /home/soft/minio/config
2. mkdir -p /home/soft/minio/data

复制代码

4. 启动MinIO容器

1. docker run -d -p 9000:9000 -p 9090:9090 --name minio -v /home/soft/minio/data:/data -v /home/soft/minio/config:/root/.minio  -e "MINIO_ACCESS_KEY=minio" -e "MINIO_SECRET_KEY=minio123" minio/minio server /data --console-address ":9090" -address ":9000"

复制代码

  

• -v /home/soft/minio/data:/data ：表示将宿主机的/soft/minio/data目录挂载到容器的/data目录
  
• -e "MINIO_ACCESS_KEY=minio"：密钥也是登录的用户名，本身设置
  
• -e "MINIO_SECRET_KEY=minio123" ：秘密密钥也是登录的暗码，本身设置
  
• --console-address ":9090" ：客户端端口为9090
  
• -address ":9000" ：服务端口为9000
  

  5. 登岸测试

三、SpringBoot集成MinIO

1. MinIO前期准备

1. 创建MinIO用户

2. 创建组

3. 创建accessKey和secretKey

4. 创建Bucket

2. springBoot整合MinIO

整合内容参考：https://blog.csdn.net/yueyue763184/article/details/131147025
1. 导入maven坐标

1. <dependency>
2.     <groupId>io.minio</groupId>
3.     <artifactId>minio</artifactId>
4.     <version>7.0.2</version>
5. </dependency>

复制代码

2. 配置 application.yml

1. server:
2.   port: 8080
3. spring:
4.   # 配置文件上传大小限制
5.   servlet:
6.     multipart:
7.       max-file-size: 200MB
8.       max-request-size: 200MB
9. minio:
10.   host: http://yourIp:9000
11.   url: ${minio.host}/${minio.bucket}/
12.   access-key: minioadmin
13.   secret-key: minioadmin
14.   bucket: public

复制代码

3. MinioConfig配置类

1. import io.minio.MinioClient;
2. import io.minio.ObjectStat;
3. import io.minio.PutObjectOptions;
4. import io.minio.Result;
5. import io.minio.messages.Bucket;
6. import io.minio.messages.Item;
7. import org.apache.tomcat.util.http.fileupload.IOUtils;
8. import org.springframework.beans.factory.InitializingBean;
9. import org.springframework.beans.factory.annotation.Value;
10. import org.springframework.stereotype.Component;
11. import org.springframework.util.Assert;
12. import org.springframework.web.multipart.MultipartFile;
13. import org.springframework.web.util.UriUtils;
15. import javax.servlet.http.HttpServletResponse;
16. import java.io.IOException;
17. import java.io.InputStream;
18. import java.net.URLEncoder;
19. import java.nio.charset.StandardCharsets;
20. import java.util.ArrayList;
21. import java.util.List;
24. @Component
25. public class MinioConfig implements InitializingBean {
27.     @Value(value = "${minio.bucket}")
28.     private String bucket;
30.     @Value(value = "${minio.host}")
31.     private String host;
33.     @Value(value = "${minio.url}")
34.     private String url;
36.     @Value(value = "${minio.access-key}")
37.     private String accessKey;
39.     @Value(value = "${minio.secret-key}")
40.     private String secretKey;
42.     private MinioClient minioClient;
44.     @Override
45.     public void afterPropertiesSet() throws Exception {
46.         Assert.hasText(url, "Minio url 为空");
47.         Assert.hasText(accessKey, "Minio accessKey为空");
48.         Assert.hasText(secretKey, "Minio secretKey为空");
49.         this.minioClient = new MinioClient(this.host, this.accessKey, this.secretKey);
50.     }
54.     /**
55.      * 上传
56.      */
57.     public String putObject(MultipartFile multipartFile) throws Exception {
58.         // bucket 不存在，创建
59.         if (!minioClient.bucketExists(this.bucket)) {
60.             minioClient.makeBucket(this.bucket);
61.         }
62.         try (InputStream inputStream = multipartFile.getInputStream()) {
63.             // 上传文件的名称
64.             String fileName = multipartFile.getOriginalFilename();
65.             // PutObjectOptions，上传配置(文件大小，内存中文件分片大小)
66.             PutObjectOptions putObjectOptions = new PutObjectOptions(multipartFile.getSize(), PutObjectOptions.MIN_MULTIPART_SIZE);
67.             // 文件的ContentType
68.             putObjectOptions.setContentType(multipartFile.getContentType());
69.             minioClient.putObject(this.bucket, fileName, inputStream, putObjectOptions);
70.             // 返回访问路径
71.             return this.url + UriUtils.encode(fileName, StandardCharsets.UTF_8);
72.         }
73.     }
75.     /**
76.      * 文件下载
77.      */
78.     public void download(String fileName, HttpServletResponse response){
79.         // 从链接中得到文件名
80.         InputStream inputStream;
81.         try {
82.             MinioClient minioClient = new MinioClient(host, accessKey, secretKey);
83.             ObjectStat stat = minioClient.statObject(bucket, fileName);
84.             inputStream = minioClient.getObject(bucket, fileName);
85.             response.setContentType(stat.contentType());
86.             response.setCharacterEncoding("UTF-8");
87.             response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8"));
88.             IOUtils.copy(inputStream, response.getOutputStream());
89.             inputStream.close();
90.         } catch (Exception e){
91.             e.printStackTrace();
92.             System.out.println("有异常：" + e);
93.         }
94.     }
96.     /**
97.      * 列出所有存储桶名称
98.      *
99.      * @return
100.      * @throws Exception
101.      */
102.     public List<String> listBucketNames()
103.             throws Exception {
104.         List<Bucket> bucketList = listBuckets();
105.         List<String> bucketListName = new ArrayList<>();
106.         for (Bucket bucket : bucketList) {
107.             bucketListName.add(bucket.name());
108.         }
109.         return bucketListName;
110.     }
112.     /**
113.      * 查看所有桶
114.      *
115.      * @return
116.      * @throws Exception
117.      */
118.     public List<Bucket> listBuckets()
119.             throws Exception {
120.         return minioClient.listBuckets();
121.     }
123.     /**
124.      * 检查存储桶是否存在
125.      *
126.      * @param bucketName
127.      * @return
128.      * @throws Exception
129.      */
130.     public boolean bucketExists(String bucketName) throws Exception {
131.         boolean flag = minioClient.bucketExists(bucketName);
132.         if (flag) {
133.             return true;
134.         }
135.         return false;
136.     }
138.     /**
139.      * 创建存储桶
140.      *
141.      * @param bucketName
142.      * @return
143.      * @throws Exception
144.      */
145.     public boolean makeBucket(String bucketName)
146.             throws Exception {
147.         boolean flag = bucketExists(bucketName);
148.         if (!flag) {
149.             minioClient.makeBucket(bucketName);
150.             return true;
151.         } else {
152.             return false;
153.         }
154.     }
156.     /**
157.      * 删除桶
158.      *
159.      * @param bucketName
160.      * @return
161.      * @throws Exception
162.      */
163.     public boolean removeBucket(String bucketName)
164.             throws Exception {
165.         boolean flag = bucketExists(bucketName);
166.         if (flag) {
167.             Iterable<Result<Item>> myObjects = listObjects(bucketName);
168.             for (Result<Item> result : myObjects) {
169.                 Item item = result.get();
170.                 // 有对象文件，则删除失败
171.                 if (item.size() > 0) {
172.                     return false;
173.                 }
174.             }
175.             // 删除存储桶，注意，只有存储桶为空时才能删除成功。
176.             minioClient.removeBucket(bucketName);
177.             flag = bucketExists(bucketName);
178.             if (!flag) {
179.                 return true;
180.             }
182.         }
183.         return false;
184.     }
186.     /**
187.      * 列出存储桶中的所有对象
188.      *
189.      * @param bucketName 存储桶名称
190.      * @return
191.      * @throws Exception
192.      */
193.     public Iterable<Result<Item>> listObjects(String bucketName) throws Exception {
194.         boolean flag = bucketExists(bucketName);
195.         if (flag) {
196.             return minioClient.listObjects(bucketName);
197.         }
198.         return null;
199.     }
201.     /**
202.      * 列出存储桶中的所有对象名称
203.      *
204.      * @param bucketName 存储桶名称
205.      * @return
206.      * @throws Exception
207.      */
208.     public List<String> listObjectNames(String bucketName) throws Exception {
209.         List<String> listObjectNames = new ArrayList<>();
210.         boolean flag = bucketExists(bucketName);
211.         if (flag) {
212.             Iterable<Result<Item>> myObjects = listObjects(bucketName);
213.             for (Result<Item> result : myObjects) {
214.                 Item item = result.get();
215.                 listObjectNames.add(item.objectName());
216.             }
217.         }
218.         return listObjectNames;
219.     }
221.     /**
222.      * 删除一个对象
223.      *
224.      * @param bucketName 存储桶名称
225.      * @param objectName 存储桶里的对象名称
226.      * @throws Exception
227.      */
228.     public boolean removeObject(String bucketName, String objectName) throws Exception {
229.         boolean flag = bucketExists(bucketName);
230.         if (flag) {
231.             List<String> objectList = listObjectNames(bucketName);
232.             for (String s : objectList) {
233.                 if(s.equals(objectName)){
234.                     minioClient.removeObject(bucketName, objectName);
235.                     return true;
236.                 }
237.             }
238.         }
239.         return false;
240.     }
242.     /**
243.      * 文件访问路径
244.      *
245.      * @param bucketName 存储桶名称
246.      * @param objectName 存储桶里的对象名称
247.      * @return
248.      * @throws Exception
249.      */
250.     public String getObjectUrl(String bucketName, String objectName) throws Exception {
251.         boolean flag = bucketExists(bucketName);
252.         String url = "";
253.         if (flag) {
254.             url = minioClient.getObjectUrl(bucketName, objectName);
255.         }
256.         return url;
257.     }
259. }

复制代码

4. MinioController控制类

1. import com.minio.demo.config.MinioConfig;
2. import org.springframework.beans.factory.annotation.Autowired;
3. import org.springframework.web.bind.annotation.*;
4. import org.springframework.web.multipart.MultipartFile;
6. import javax.servlet.http.HttpServletResponse;
7. import java.util.List;
9. @RestController
10. @CrossOrigin
11. @RequestMapping("/minio")
12. public class MinioController {
14.     @Autowired
15.     MinioConfig minioConfig;
17.     // 上传
18.     @PostMapping("/upload")
19.     public Object upload(@RequestParam("file") MultipartFile multipartFile) throws Exception {
20.         return this.minioConfig.putObject(multipartFile);
21.     }
23.     // 下载文件
24.     @GetMapping("/download")
25.     public void download(@RequestParam("fileName")String fileName, HttpServletResponse response) {
26.         this.minioConfig.download(fileName,response);
27.     }
29.     // 列出所有存储桶名称
30.     @PostMapping("/list")
31.     public List<String> list() throws Exception {
32.         return this.minioConfig.listBucketNames();
33.     }
35.     // 创建存储桶
36.     @PostMapping("/createBucket")
37.     public boolean createBucket(String bucketName) throws Exception {
38.         return this.minioConfig.makeBucket(bucketName);
39.     }
41.     // 删除存储桶
42.     @PostMapping("/deleteBucket")
43.     public boolean deleteBucket(String bucketName) throws Exception {
44.         return this.minioConfig.removeBucket(bucketName);
45.     }
47.     // 列出存储桶中的所有对象名称
48.     @PostMapping("/listObjectNames")
49.     public List<String> listObjectNames(String bucketName) throws Exception {
50.         return this.minioConfig.listObjectNames(bucketName);
51.     }
53.     // 删除一个对象
54.     @PostMapping("/removeObject")
55.     public boolean removeObject(String bucketName, String objectName) throws Exception {
56.         return this.minioConfig.removeObject(bucketName, objectName);
57.     }
59.     // 文件访问路径
60.     @PostMapping("/getObjectUrl")
61.     public String getObjectUrl(String bucketName, String objectName) throws Exception {
62.         return this.minioConfig.getObjectUrl(bucketName, objectName);
63.     }
64. }

复制代码

5. 测试

6. 验证

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。