官方介紹：
MinIO 提供高性能、與S3 兼容的對(duì)象存儲(chǔ)系統(tǒng)，讓你自己能夠構(gòu)建自己的私有云儲(chǔ)存服務(wù)。在 GNU AGPL v3 下是 100% 開源的。

• 部署簡(jiǎn)單，只有一個(gè)minio可執(zhí)行文件。
• 高性能，在 32 個(gè) NVMe 驅(qū)動(dòng)器節(jié)點(diǎn)和 100Gbe 網(wǎng)絡(luò)上發(fā)布的 GET/PUT 結(jié)果超過 325 GiB/秒和 165 GiB/秒。
• Kubernetes原生支持，MinIO 支持公共云、私有云和邊緣云上所有主要的 Kubernetes 發(fā)行版。

1、MinIO安裝部署

1.1 下載

下載地址：https://min.io/download#/linux
linux下載：

wget https://dl.min.io/server/minio/release/linux-amd64/minio
chmod +x minio

啟動(dòng)命令：

minio server [FLAGS] HOSTNAME/DIRECTORIES [HOSTNAME/DIRECTORIES..]

服務(wù)器列表

單機(jī)啟動(dòng)

MINIO_ROOT_USER=admin MINIO_ROOT_PASSWORD=12345678 ./minio server --address ":9000" --console-address ":9001" /data/minio/data

集群?jiǎn)?dòng)

MINIO_ROOT_USER=admin MINIO_ROOT_PASSWORD=12345678 ./minio server \
--address ":9000" --console-address ":9001"  \
http://192.168.245.134:9000/data/minio/data  \
http://192.168.245.137:9000/data/minio/data

Minio分布式注意事項(xiàng)：

• 所有的節(jié)點(diǎn)需要有相同的access（用戶名）和secret（密碼）
• 存放數(shù)據(jù)的磁盤目錄必須是空目錄
• 官方建議生產(chǎn)環(huán)境最少4個(gè)節(jié)點(diǎn)，因?yàn)橛蠳個(gè)節(jié)點(diǎn)，得至少保證有N/2的節(jié)點(diǎn)才能可讀，保證至少N/2+1的節(jié)點(diǎn)才能可寫。
• 節(jié)點(diǎn)時(shí)間必須同步，不能有大差距。
• 每個(gè)節(jié)點(diǎn)磁盤都存一份數(shù)據(jù)文件保證數(shù)據(jù)的可靠性與安全性

報(bào)錯(cuò)：

Error: Drive `/data/minio/data/data` is part of root drive, will not be used (*errors.errorString)

錯(cuò)誤:驅(qū)動(dòng)器’ /data/minio/data/data '是根驅(qū)動(dòng)器的一部分，將不會(huì)被使用。分布式需要使用另外的掛載硬盤。
掛載硬盤方法：

# 查看未掛載的磁盤
[root@localhost]# fdisk -l

# 對(duì)新建的磁盤/dev/sdb進(jìn)行分區(qū)
[root@localhost]# fdisk /dev/sdb
#輸入n，#添加新的分區(qū)
#輸入p，回車，#打印分區(qū)
#默認(rèn)分區(qū)輸入1，兩次回車，
#輸入w，保存分區(qū)并退出

# 格式化
[root@localhost]# mkfs -t ext4 /dev/sdb1

# 掛載硬盤
[root@localhost]# mount /dev/sdb1  /data/minio

# 設(shè)置開機(jī)自動(dòng)掛載
[root@localhost]# blkid /dev/sdb1 # 查看設(shè)備UUID
[root@localhost]# vim /etc/fstab
#第一字段:分區(qū)設(shè)備文件名或UUID(硬盤通用唯一識(shí)別碼，可通過“blkid /dev/sdb1”查看UUID)
#第二字段:掛載點(diǎn)（/data/minio）
#第三字段:文件系統(tǒng)名稱（ext4）
#第四字段:掛載參數(shù)（defaults）
#第五字段:指定分區(qū)是否被dump備份,0代表不備份,1代表每天備份,2代表不定期備份
#第六字段:指定分區(qū)是否被fsck檢測(cè),0代表不檢測(cè),其它數(shù)字代表檢測(cè)的優(yōu)先級(jí),1的優(yōu)先級(jí)比2高

2、管理工具

MinIO提供了一套選項(xiàng)來涵蓋數(shù)據(jù)驅(qū)動(dòng)型企業(yè)中的每個(gè)角色，例如圖形用戶界面（GUI），命令行界面（CLI）和應(yīng)用程序編程接口（API）。

2.1、圖形管理工具

瀏覽器訪問http://192.168.245.139:9001，使用上邊設(shè)置的帳號(hào)密碼例登錄。

設(shè)置目錄或文件允許直接訪問：

2.2、命令管理工具

mc 是用來訪問MinIO服務(wù)的命令行客戶端，參考 https://min.io/docs/minio/linux/reference/minio-mc.html?ref=docs
MinIO 客戶端 mc 命令行工具提供了一個(gè)類UNIX命令的替代，例如 ls, cat, cp, mirror, 以及 diff ，同時(shí)支持文件系統(tǒng)和亞馬遜的 S3兼容云存儲(chǔ)服務(wù).
下載地址：https://dl.min.io/client/mc/release/linux-amd64/mc

mc alias set minio1 hhttp://192.168.245.139:9000 admin 12345678
mc alias set minio2 hhttp://192.168.245.137:9000 admin 12345678

mc alias list
mc ls minio1

2.3、Java SDK管理工具

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.penngo.example</groupId>
    <artifactId>minio-service</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <version>8.5.5</version>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>2022.0.0.0</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>2022.0.4</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>3.0.9</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <!-- 配置 fork 進(jìn)行熱部署支持  -->
                <configuration>
                    <mainClass>com.penngo.example.MinioApp</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

application.yml

server:
  port: 8080
  servlet:
    encoding:
      force: true
      charset: UTF-8
      enabled: true
minio:
  access-key: admin
  secret-key: 12345678
  url: http://192.168.245.139:9000

MinioConfig.java

package com.penngo.example.component;

import io.minio.MinioClient;
import io.minio.messages.Bucket;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.List;

@Configuration
@ConfigurationProperties(prefix = "minio")
public class MinioConfig {
    /**
     * 用戶名
     */
    private String accessKey;
    /**
     * 密碼
     */
    private String secretKey;
    /**
     * Minio 服務(wù)端 api地址
     */
    private String url;

    public void setAccessKey(String accessKey) {
        this.accessKey = accessKey;
    }

    public void setSecretKey(String secretKey) {
        this.secretKey = secretKey;
    }

    public void setUrl(String url) {
        this.url = url;
    }


    public String getAccessKey() {
        return accessKey;
    }

    public String getSecretKey() {
        return secretKey;
    }

    public String getUrl() {
        return url;
    }


    /**
     * 構(gòu)建 操作Minio的客戶端
     * @return
     */
    @Bean("minioClient")
    public MinioClient minioClient() {
        System.out.println(url + "," + accessKey + "," + secretKey);
        MinioClient minioClient = MinioClient.builder()
                .endpoint(url)
                .credentials(accessKey, secretKey)
                .build();
        try{
            List<Bucket> list = minioClient.listBuckets();
            System.out.println("Bucket List:" + list.size());
        }
        catch(Exception e){
            e.printStackTrace();
        }
        return minioClient;
    }
}

MinioUtils.java

package com.penngo.example.component;

import io.minio.*;
import io.minio.http.Method;
import io.minio.messages.Item;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Component;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

@Component
public class MinioUtils {
    private String bucketName = "test-bucket";
    @Resource
    private MinioClient minioClient;

    /**
     * 創(chuàng)建桶
     */
    public boolean createBucket(){
        try{
            boolean found = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
            if (!found) {
                minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
            }
            return true;
        }
        catch(Exception e){
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 刪除桶
     */
    public void removeBucket(String bucketName) throws Exception{
        minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
    }

    /**
     * 上傳文件
     */
    public boolean uploadFile(String fileName, InputStream stream, Long fileSize, String type){
        try{
            minioClient.putObject(PutObjectArgs.builder().bucket(bucketName).object(fileName).stream(stream, fileSize, -1)
                    .contentType(type).build());
            return true;
        }
        catch(Exception e){
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 判斷文件夾是否存在
     * @return
     */
    public Boolean folderExists(String bucketName, String prefix) throws Exception{
        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;
    }

    /**
     * 創(chuàng)建文件夾
     *
     * @param bucketName 桶名稱
     * @param path 路徑
     */
    public void createFolder(String bucketName, String path) throws Exception{
        minioClient.putObject(PutObjectArgs.builder().bucket(bucketName).object(path)
                .stream(new ByteArrayInputStream(new byte[] {}), 0, -1).build());
    }

    /**
     * 獲取文件在minio在服務(wù)器上的外鏈
     *
     */
    public String getUrl(String objectName) throws Exception{
        return minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder().method(Method.GET).bucket(
                bucketName).object(objectName).expiry(1, TimeUnit.DAYS).build());
    }

    /**
     * 獲取minio中,某個(gè)bucket中所有的文件名
     */
    public Map<String, String> getFileList() {
        Iterable<Result<Item>> results = minioClient.listObjects(ListObjectsArgs.builder().bucket(bucketName)
                .recursive(true).build());
        Map<String, String> fileUrlData = new HashMap<>();
        for (Result<Item> result : results) {
            Item item;
            String fileName = null;
            try {
                item = result.get();
                fileName = item.objectName();
                String url = getUrl(fileName);
                fileUrlData.put(fileName, url);
            } catch (Exception e) {
               e.printStackTrace();
            }
        }
        return fileUrlData;
    }
}

FileController.java

package com.penngo.example.controlleer;

import com.penngo.example.component.MinioUtils;
import jakarta.annotation.Resource;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.io.File;
import java.io.FileInputStream;
import java.util.Map;

@RestController
public class FileController {

    @Resource
    private MinioUtils minioUtils;

    @GetMapping("/hello")
    public String hello(){
        return "FileController:Hello";
    }
    /**
     * 創(chuàng)建桶
     */
    @GetMapping("/createBucket")
    public String createBucket() throws Exception{
        boolean b = minioUtils.createBucket();
        return "createBucket:" + b;
    }

    /**
     * 上傳文件
     */
    @GetMapping("/uploadFile")
    public String uploadFile(){
        String filePath = "D:\\project\\測(cè)試.docx";
        File file = new File(filePath);
        boolean b = false;
        try {
            FileInputStream fileInputStream = new FileInputStream(file);
            b = minioUtils.uploadFile(file.getName(), fileInputStream, file.length(), "application/vnd.openxmlformats-officedocument.wordprocessingml.document");
        }
        catch(Exception e){
            e.printStackTrace();
        }
        return "uploadFile:" + b;
    }
    @GetMapping("/fileList")
    public String fileList(){
        Map<String, String> files =  minioUtils.getFileList();
        StringBuffer sff = new StringBuffer();
        files.forEach((k,v)->{
            sff.append(k).append(":<a target='blank' href=").append(v).append(">").append(v).append("</a><br/>");
        });
        return sff.toString();
    }
}

MinioApp.java

package com.penngo.example;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MinioApp {
    public static void main(String[] args) {
        SpringApplication.run(MinioApp.class, args);
    }
}

運(yùn)行效果：


更多官方j(luò)ava例子:https://github.com/minio/minio-java/tree/release/examples

3、MinIO Server配置參數(shù)

3.1、啟動(dòng)參數(shù)：

• HOSTNAME
  minio服務(wù)器進(jìn)程的主機(jī)名。

https://minio1.example.net
https://minio2.example.net

• DIRECTORIES
  必須，minio存儲(chǔ)的目錄。

/mnt/data1
/mnt/data2

• –address
  可選，將minio綁定到特定的網(wǎng)絡(luò)地址和端口號(hào)。將地址和端口指定為address: port，

#/etc/hosts
127.0.1.1       minioip
127.0.1.2       minioip

#啟動(dòng)
minio server --address "minioip:9000" ~/miniodirectory

• –console-address
  可選，minio管理控制臺(tái)的靜態(tài)端口。

• –ftp
  可選，啟用并配置FTP (File Transfer Protocol)或FTPS (File Transfer Protocol over SSL/TLS)服務(wù)器。

minio server http://server{1...4}/disk{1...4} \
--ftp="address=:8021"                         \
--ftp="passive-port-range=30000-40000"        \
--ftp="tls-private-key=path/to/private.key"   \
--ftp="tls-public-cert=path/to/public.crt"    \
...

• –sftp
  可選，啟用并配置SFTP服務(wù)器。

minio server http://server{1...4}/disk{1...4}                               \
--sftp="address=:8022" --sftp="ssh-private-key=/home/miniouser/.ssh/id_rsa" \
...

• –certs-dir, -S
  可選，minio進(jìn)程用于配置TLS/SSL連接的證書所在文件夾的路徑。

• –quiet
  可選，禁用啟動(dòng)信息。

• –anonymous
  可選，在日志記錄中隱藏敏感信息。

• –json
  可選，以JSON格式輸出服務(wù)器日志和啟動(dòng)信息。

3.2、環(huán)境變量

• MINIO_VOLUMES
  minio服務(wù)器進(jìn)程用作存儲(chǔ)后端的目錄或驅(qū)動(dòng)器。
  功能上等同于設(shè)置minio服務(wù)器目錄。在配置MinIO使用環(huán)境文件運(yùn)行時(shí)使用此值。

# MinIO configuration file
MINIO_VOLUMES="/data/minio" #配置存儲(chǔ)目錄
MINIO_OPTS="-C /etc/minio --address :9000" #配置minio監(jiān)聽端口
MINIO_ROOT_USER="minioadmin" #配置用戶名
MINIO_ROOT_PASSWORD="minioadmin" #配置密碼
#MINIO_OPTS="--address 0.0.0.0:9000 --console-address '0.0.0.0:9001'"  #指定控制臺(tái)端口，不指定則默認(rèn)和minio一致

MINIO_CONFIG_ENV_FILE
指定MinIO服務(wù)器進(jìn)程用于加載環(huán)境變量的文件的完整路徑。

docker run -dt \
--name "minio_local" \
--net=host \
-v /momo/app/minio/data:/mnt/data \
-v /momo/app/minio/config/config.env:/etc/config.env \
-e "MINIO_CONFIG_ENV_FILE=/etc/config.env" \
bitnami/minio:2022.9.17 \
minio server --console-address ":9990"

MINIO_ILM_EXPIRY_WORKERS
使用ILM過期規(guī)則檢查過期對(duì)象的工作線程數(shù)。如果沒有設(shè)置，MinIO默認(rèn)使用最多一半的可用內(nèi)核。

MINIO_DOMAIN
配置minio支持基于域名的訪問模式

export MINIO_DOMAIN=minio.domain

MINIO_SCANNER_SPEED
在平衡MinIO讀/寫性能到掃描器進(jìn)程時(shí)，管理掃描器的最大等待時(shí)間。

3.3、Root驗(yàn)證參數(shù)

MINIO_ROOT_USER
root用戶的訪問鍵。

MINIO_ROOT_PASSWORD
root用戶的密鑰。

MINIO_API_ROOT_ACCESS
Minio API root訪問權(quán)限

MINIO_API_ROOT_ACCESS
指定on為啟用，off為禁用根用戶帳戶。禁用root服務(wù)帳戶也會(huì)禁用與root關(guān)聯(lián)的所有服務(wù)帳戶，但不包括用于站點(diǎn)復(fù)制的服務(wù)帳戶。默認(rèn)為開啟。

配置參考：https://min.io/docs/minio/linux/reference/minio-server/minio-server.html#command-minio.server

4、MinIO Client可用命令

mc可以命令

官方參考：https://min.io/docs/minio/linux/reference/minio-mc.html文章來源地址http://www.zghlxwxcb.cn/news/detail-696897.html

到了這里，關(guān)于開源對(duì)象存儲(chǔ)系統(tǒng)minio部署配置與SpringBoot客戶端整合訪問的文章就介紹完了。如果您還想了解更多內(nèi)容，請(qǐng)?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！