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

文章目录

• • 1、MinIO安装部署
  • • [1.1 下载](#1.1 下载)
  • 2、管理工具
  • • 2.1、图形管理工具
    • 2.2、命令管理工具
    • [2.3、Java SDK管理工具](#2.3、Java SDK管理工具)
  • [3、MinIO Server配置参数](#3、MinIO Server配置参数)
  • • 3.1、启动参数：
    • 3.2、环境变量
    • 3.3、Root验证参数
  • [4、MinIO Client可用命令](#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兼容服务的桶事件通知。

官方参考：https://min.io/docs/minio/linux/reference/minio-mc.html