开源对象存储系统minio部署配置与SpringBoot客户端整合访问

文章目录

- 1、MinIO安装部署
- - 1.1 下载
- 2、管理工具
- - 2.1、图形管理工具
  - 2.2、命令管理工具
  - 2.3、Java SDK管理工具
- 3、MinIO Server配置参数
- - 3.1、启动参数：
  - 3.2、环境变量
  - 3.3、Root验证参数
- 4、MinIO Client可用命令

官方介绍：
MinIO 提供高性能、与S3 兼容的对象存储系统，让你自己能够构建自己的私有云储存服务。在 GNU AGPL v3 下是 100% 开源的。

部署简单，只有一个minio可执行文件。
高性能，在 32 个 NVMe 驱动器节点和 100Gbe 网络上发布的 GET/PUT 结果超过 325 GiB/秒和 165 GiB/秒。
Kubernetes原生支持，MinIO 支持公共云、私有云和边缘云上所有主要的 Kubernetes 发行版。

1、MinIO安装部署

1.1 下载

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

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

启动命令：

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

服务器列表

服务器	存储目录
192.168.245.134	/data/minio/data
192.168.245.137	/data/minio/data

单机启动

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

集群启动

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分布式注意事项：

所有的节点需要有相同的access（用户名）和secret（密码）
存放数据的磁盘目录必须是空目录
官方建议生产环境最少4个节点，因为有N个节点，得至少保证有N/2的节点才能可读，保证至少N/2+1的节点才能可写。
节点时间必须同步，不能有大差距。
每个节点磁盘都存一份数据文件保证数据的可靠性与安全性

报错：

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

错误:驱动器’ /data/minio/data/data '是根驱动器的一部分，将不会被使用。分布式需要使用另外的挂载硬盘。
挂载硬盘方法：

# 查看未挂载的磁盘
[root@localhost]# fdisk -l

# 对新建的磁盘/dev/sdb进行分区
[root@localhost]# fdisk /dev/sdb
#输入n，#添加新的分区
#输入p，回车，#打印分区
#默认分区输入1，两次回车，
#输入w，保存分区并退出

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

# 挂载硬盘
[root@localhost]# mount /dev/sdb1  /data/minio

# 设置开机自动挂载
[root@localhost]# blkid /dev/sdb1 # 查看设备UUID
[root@localhost]# vim /etc/fstab
#第一字段:分区设备文件名或UUID(硬盘通用唯一识别码，可通过“blkid /dev/sdb1”查看UUID)
#第二字段:挂载点（/data/minio）
#第三字段:文件系统名称（ext4）
#第四字段:挂载参数（defaults）
#第五字段:指定分区是否被dump备份,0代表不备份,1代表每天备份,2代表不定期备份
#第六字段:指定分区是否被fsck检测,0代表不检测,其它数字代表检测的优先级,1的优先级比2高

在这里插入图片描述

2、管理工具

MinIO提供了一套选项来涵盖数据驱动型企业中的每个角色，例如图形用户界面（GUI），命令行界面（CLI）和应用程序编程接口（API）。

2.1、图形管理工具

浏览器访问http://192.168.245.139:9001，使用上边设置的帐号密码例登录。

设置目录或文件允许直接访问：
在这里插入图片描述

2.2、命令管理工具

mc 是用来访问MinIO服务的命令行客户端，参考 https://min.io/docs/minio/linux/reference/minio-mc.html?ref=docs
MinIO 客户端 mc 命令行工具提供了一个类UNIX命令的替代，例如 ls, cat, cp, mirror, 以及 diff ，同时支持文件系统和亚马逊的 S3兼容云存储服务.
下载地址：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 进行热部署支持  -->
                <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 服务端 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;
    }


    /**
     * 构建 操作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;

    /**
     * 创建桶
     */
    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;
    }

    /**
     * 创建文件夹
     *
     * @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在服务器上的外链
     *
     */
    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中,某个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";
    }
    /**
     * 创建桶
     */
    @GetMapping("/createBucket")
    public String createBucket() throws Exception{
        boolean b = minioUtils.createBucket();
        return "createBucket:" + b;
    }

    /**
     * 上传文件
     */
    @GetMapping("/uploadFile")
    public String uploadFile(){
        String filePath = "D:\\project\\测试.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);
    }
}

运行效果：
在这里插入图片描述

更多官方java例子:https://github.com/minio/minio-java/tree/release/examples

3、MinIO Server配置参数

3.1、启动参数：

HOSTNAME
minio服务器进程的主机名。

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

DIRECTORIES
必须，minio存储的目录。

/mnt/data1
/mnt/data2

–address
可选，将minio绑定到特定的网络地址和端口号。将地址和端口指定为address: port，

#/etc/hosts
127.0.1.1       minioip
127.0.1.2       minioip

#启动
minio server --address "minioip:9000" ~/miniodirectory

–console-address
可选，minio管理控制台的静态端口。
–ftp
可选，启用并配置FTP (File Transfer Protocol)或FTPS (File Transfer Protocol over SSL/TLS)服务器。

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服务器。

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进程用于配置TLS/SSL连接的证书所在文件夹的路径。
–quiet
可选，禁用启动信息。
–anonymous
可选，在日志记录中隐藏敏感信息。
–json
可选，以JSON格式输出服务器日志和启动信息。

3.2、环境变量

MINIO_VOLUMES
minio服务器进程用作存储后端的目录或驱动器。
功能上等同于设置minio服务器目录。在配置MinIO使用环境文件运行时使用此值。

# MinIO configuration file
MINIO_VOLUMES="/data/minio" #配置存储目录
MINIO_OPTS="-C /etc/minio --address :9000" #配置minio监听端口
MINIO_ROOT_USER="minioadmin" #配置用户名
MINIO_ROOT_PASSWORD="minioadmin" #配置密码
#MINIO_OPTS="--address 0.0.0.0:9000 --console-address '0.0.0.0:9001'"  #指定控制台端口，不指定则默认和minio一致

MINIO_CONFIG_ENV_FILE
指定MinIO服务器进程用于加载环境变量的文件的完整路径。

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过期规则检查过期对象的工作线程数。如果没有设置，MinIO默认使用最多一半的可用内核。

MINIO_DOMAIN
配置minio支持基于域名的访问模式

export MINIO_DOMAIN=minio.domain

MINIO_SCANNER_SPEED
在平衡MinIO读/写性能到扫描器进程时，管理扫描器的最大等待时间。

3.3、Root验证参数

MINIO_ROOT_USER
root用户的访问键。

MINIO_ROOT_PASSWORD
root用户的密钥。

MINIO_API_ROOT_ACCESS
Minio API root访问权限

MINIO_API_ROOT_ACCESS
指定on为启用，off为禁用根用户帐户。禁用root服务帐户也会禁用与root关联的所有服务帐户，但不包括用于站点复制的服务帐户。默认为开启。

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

4、MinIO Client可用命令

mc可以命令

Command	Description
`mc alias list` `mc alias remove` `mc alias set`	mc alias命令提供了一个方便的界面，用于管理与s3兼容的主机列表，mc可以连接到这些主机并对其运行操作。
`mc anonymous get` `mc anonymous get-json` `mc anonymous links` `mc anonymous list` `mc anonymous set` `mc anonymous set-json`	mc anonymous命令支持对桶及其内容进行匿名策略设置或删除。允许匿名策略公共访问的桶，客户端可以无需身份验证执行策略授予的任何操作。
`mc batch describe` `mc batch generate` `mc batch list` `mc batch start` `mc batch status`	mc batch命令允许您在MinIO部署中运行一个或多个作业任务。
`mc cat`	`mc cat`命令将一个文件或对象的内容连接到另一个文件或对象。还可以使用该命令将指定文件或对象的内容显示为STDOUT。Cat具有与Cat相似的功能。
`mc cp`	`mc cp`命令将对象复制到MinIO部署或从MinIO部署复制对象，其中源可以是MinIO，也可以是本地文件系统。
`mc diff`	`mc diff` mc计算两个文件系统目录或MinIO桶之间的差异。`mc diff`只列出那些丢失的或大小不同的对象。`mc diff`不比较对象的内容。
`mc du`	`mc du`命令汇总了桶和文件夹的磁盘使用情况。您还可以对本地文件系统使用du来产生与du命令类似的结果。
`mc encrypt clear` `mc encrypt info` `mc encrypt set`	mc encrypt命令用于设置、更新或禁用桶的默认SSE (Server-Side Encryption)模式。MinIOl默认对象加密使用指定的SSE模式。
`mc event add` `mc event ls` `mc event rm`	mc event命令支持添加、删除和列出桶事件通知。
`mc find`	mc find命令支持在MinIO部署中搜索对象，也支持搜索文件系统上的文件。
`mc head`	mc head命令显示对象的前n行，其中n是指定给命令的参数。
`mc idp ldap add` `mc idp ldap disable` `mc idp ldap enable` `mc idp ldap info` `mc idp ldap ls` `mc idp ldap policy` `mc idp ldap rm` `mc idp ldap update`	mc idp ldap命令允许您管理第三方Active Directory或ldap Identity and Access Management (IAM)集成的配置。
`mc idp openid add` `mc idp openid disable` `mc idp openid enable` `mc idp openid info` `mc idp openid ls` `mc idp openid rm` `mc idp openid update`	mc idp openid命令用于管理第三方openid IAM (Identity and Access Management)集成的配置。
`mc idp ldap policy attach` `mc idp ldap policy detach` `mc idp ldap policy entities`	mc idp ldap policy命令用来查询ldap策略与关联的组或用户的映射关系。
`mc ilm restore` `mc ilm rule add` `mc ilm rule edit` `mc ilm rule export` `mc ilm rule import` `mc ilm rule ls` `mc ilm rule rm` `mc ilm tier add` `mc ilm tier check` `mc ilm tier info` `mc ilm tier ls` `mc ilm tier rm` `mc ilm tier update`	mc ilm命令管理MinIO部署中的对象生命周期管理规则和分层。
`mc legalhold clear` `mc legalhold info` `mc legalhold set`	mc legalhold命令用来设置、移除或检索对象的WORM (Object Legal Hold)设置。
`mc license info` `mc license register` `mc license update`	mc license命令用于MinIO子网的集群注册。使用这些命令注册部署、注销部署、显示有关集群当前许可证的信息或更新集群的许可证密钥。
`mc ls`	mc ls命令列出MinIO或其他兼容s3的服务上的桶和对象。
`mc mb`	mc mb命令在指定的路径上创建一个新的桶或目录。
`mc mirror`	mc mirror命令将内容同步到MinIO部署，类似于rsync实用程序。mc mirror支持文件系统、MinIO部署和其他兼容s3的主机作为同步源。
`mc mv`	mc mv命令将对象从源移动到目标，例如在MinIO部署之间或同一MinIO部署上的桶之间。mc mv还支持在本地文件系统和MinIO之间移动对象。
`mc od`	mc命令将本地文件以指定的部件数量和部件尺寸复制到远程位置。该命令输出上传文件所需的时间。
`mc ping`	mc ping命令对指定的目标执行活动检查。
`mc pipe`	mc pipe命令将内容从STDIN流到目标对象。
`mc quota clear` `mc quota info` `mc quota set`	mc quota命令用于设置、显示和删除存储桶的硬配额限制。
`mc rb`	mc rb命令删除MinIO或其他s3兼容服务上的一个或多个bucket。若要仅删除bucket的内容，请使用mc rm。
`mc replicate add` `mc replicate backlog` `mc replicate export` `mc replicate import` `mc replicate ls` `mc replicate resync` `mc replicate rm` `mc replicate status` `mc replicate update`	mc replicate 命令用于配置和管理MinIO部署的服务器端桶复制，包括双活复制配置和重新同步。
`mc retention clear` `mc retention info` `mc retention set`	mc retention命令用来为桶中的一个或多个对象配置WORM (Write-Once Read-Many)锁定设置。您还可以设置桶的默认对象锁设置，其中所有没有显式对象锁设置的对象都继承桶的默认设置。
`mc rm`	mc rm命令从MinIO部署的bucket中删除对象。要完全删除一个桶，使用mc rb代替。
`mc share download` `mc share ls` `mc share upload`	使用mc share命令管理预先指定的url，用于下载和上传对象到MinIO桶。
`mc sql`	mc sql命令提供S3 Select接口，用于对指定MinIO部署的对象执行sql查询。
`mc stat`	mc stat命令显示MinIO桶中对象的信息，包括对象元数据。
`mc support callhome` `mc support diag` `mc support inspect` `mc support perf` `mc support profile` `mc support proxy` `mc support top api` `mc support top disk` `mc support top locks`	MinIO Client mc支持命令提供了分析部署运行状况或性能以及运行诊断的工具。您还可以上传生成的运行状况报告，以供MinIO工程进一步分析。
`mc tag list` `mc tag remove` `mc tag set`	mc tag命令添加、删除和列出与桶或对象相关的标记。
`mc tree`	mc tree命令以树形格式列出MinIO bucket中的所有前缀。该命令可选地支持在每个前缀处列出桶内的所有对象，包括桶根。
`mc undo`	mc undo命令撤销由于在指定路径上执行PUT或DELETE操作而导致的更改。
`mc update`	mc update命令会自动将mc二进制文件更新到最新的稳定版本。
`mc version enable` `mc version info` `mc version suspend`	mc version命令用于启用、禁用和检索MinIO桶的版本控制状态。
`mc watch`	mc watch命令监视指定的MinIO桶或本地文件系统路径上的事件。对于S3服务，使用mc event add配置S3兼容服务的桶事件通知。