MinIo新旧版本工具类和部署文档

最新推荐文章于 2024-07-13 14:14:37 发布
最新推荐文章于 2024-07-13 14:14:37 发布
阅读量2.6k 收藏 4
点赞数
分类专栏： java后台 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/panpeichang/article/details/116235058
版权

work文档格式，后面再调整

MinIO 使用文档
下载安装
官网下载地址：https://min.io/download

注：本文档使用的目录和ip要根据自己项目设置
单机部署
1.创建目录
1.1创建保存minio目录
mkdir -p /minio
1.2创建启动目录
mkdir -p /minio/bin/
1.3创建minio bucket目录，即上传文件保存目录
mkdir -p /minio/data

2.创建启动脚本
start.sh
#!/bin/bash
#设置用户名和密码
export MINIO_ACCESS_KEY=panys
export MINIO_SECRET_KEY=panys123456
#设置端口 --address ip:port
#后台启动
nohup /minio/minio server --address 192.168.201.149:9002 /minio/data/ > /minio/logs/minio.log 2>&1 &


3.创建停止脚本
#!/bin/bash
#停止 stop
ps -ef | grep -w minio | grep -v grep | awk '{print $2}'|xargs kill -9


4.授权
4.1授权minio文件
chmod +x minio
4.2给脚本start.sh和stop.sh授权
chmod+x start.sh stop.sh
5.启动测试
运行启动脚本
./minio/bin/start.sh
在浏览器上输入访问地址http://192.168.201.149:9002，测试创建bucket和上传文件

显示上图代表单机部署成功

集群部署
因为官方推荐集群部署需要四个节点，所以本文档使用两台机器，每台机器两个磁盘模式部署
192.168.201.149  /minio/data   /minio/data2
192.168.201.150  /minio/data   /minio/data2
   
1.创建目录
1.1创建保存minio目录
mkdir -p /minio
上传下载的minio文件到minio目录
1.2创建启动目录
mkdir -p /minio/bin/
1.3创建minio bucket目录
即上传文件保存目录，两台机器都需要创建
mkdir -p /minio/{data,data2}
2.创建启动脚本
start.sh
#!/bin/bash
#设置用户名和密码
export MINIO_ACCESS_KEY=panys
export MINIO_SECRET_KEY=panys123456
#修改访问 --address ip:port
#后台启动
nohup /minio/minio server --address 0.0.0.0:9002 http://192.168.201.149/minio/data http://192.168.201.149/minio/data2 http://192.168.201.150/minio/data http://192.168.201.150/minio/data2 > /minio/logs/minio.log 2>&1 &


3.创建停止脚本
stop.sh
#!/bin/bash
#停止 stop
ps -ef | grep -w minio | grep -v grep | awk '{print $2}'|xargs kill -9

4.授权
两台机器都需要执行
4.1授权minio文件
chmod +x minio
4.2给脚本start.sh和stop.sh授权
chmod+x start.sh stop.sh

5.启动测试
两台机器运行启动脚本
./minio/bin/start.sh
在浏览器上输入访问地址http://192.168.201.149:9002，测试创建bucket和上传文件

在浏览器上输入访问地址http://192.168.201.150:9002,如果有相同的文件则集群部署minio成功。
Nginx代理
minio集群部署，提供统一访问路径，可以使用nginx配置负载均衡
如下：
upstream minio{
	server 192.168.201.149:9002;
	server 192.168.201.150:9002;
}
server {
	listen 9002;
	server_name minio;
	location / {
		proxy_set_header Host $http_host;
		proxy_set_header X-Forwarded-For $remote_addr;
		client_body_buffer_size 10M;
		client_max_body_size 10G;
		proxy_buffers 1024 4k;
		proxy_read_timeout 300;
		proxy_next_upstream error timeout http_404;
		proxy_pass http://minio;
	}
}

整合springboot 2.x API
Java client API 官方文档
https://docs.min.io/docs/java-client-quickstart-guide.html

说明：minio从7.0.2版本后开始变化，API有所区别，规范了参数

配置文件yaml
# minio 配置,endpoint访问路径，accessKey 用户名，secretKey 密码，bucketName 存储桶
min:
  io:
    endpoint: http://192.168.201.148:9002
    accessKey: aaa
secretKey: aaa123456
bucketName: test


旧版
引入maven文件
旧版：
<dependency>
	<groupId>io.minio</groupId>
	<artifactId>minio</artifactId>
	<version>7.0.2</version>
</dependency>
新版：
<dependency>
	<groupId>io.minio</groupId>
	<artifactId>minio</artifactId>
	<version>8.2.1</version>
</dependency>

工具类
MinIoProperties
package cn.emd.platform.common.file.config;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * MinIo实体参数类
 *
 * @author pan
 * @date 2021/4/26
 */
@Data
@Component
@ConfigurationProperties(prefix = "min.io")
public class MinIoProperties {

    /**
     * 访问地址
     */
    private String endpoint;

    /**
     * 用户名
     */
    private String accessKey;

    /**
     * 密码
     */
    private String secretKey;

    /**
     * 存储桶
     */
    private String bucketName="pan";

}


特殊参数说明
objectName存储桶的文件名，可以是文件，也可以是文件夹+文件
例如：Entity.vm或者pan/Entity.vm
filename 文件所在地址，上传文件时文件所在位置地址
例如：D://Entity.vm
fileName 文件保存地址,下载时保存文件位置地址
例如：D://pan/entity.vm 

旧版工具类
MinIoUtils

package cn.emd.platform.common.file.util;

import cn.emd.platform.common.core.exception.DynamicException;
import cn.emd.platform.common.file.config.MinIoProperties;
import io.minio.MinioClient;
import io.minio.PutObjectOptions;
import io.minio.errors.*;

import lombok.SneakyThrows;
import org.apache.commons.lang3.StringUtils;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.PostConstruct;
import java.io.InputStream;

/**
 * MinIo工具类
 *
 * @author pan
 * @date 2021/4/25
 */
@Component
@Configuration
@EnableConfigurationProperties(MinIoProperties.class)
public class MinIoUtils {

    private MinIoProperties minIoProperties;
    private MinioClient minioClient;

    public MinIoUtils(MinIoProperties minIoProperties){
        this.minIoProperties=minIoProperties;
    }

    @PostConstruct
    public void init(){
        try {
            minioClient=new MinioClient(minIoProperties.getEndpoint(),
                    minIoProperties.getAccessKey(),
                    minIoProperties.getSecretKey());
            //创建一个默认的bucket
            boolean found =this.bucketExists(minIoProperties.getBucketName());
            if (!found) {
                this.makeBucket(minIoProperties.getBucketName());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 判断是否存在 bucket
     * @param bucketName 存储桶
     * @return 存在true,不存在false
     */
    public Boolean bucketExists(String bucketName){

        try {
            return minioClient.bucketExists(bucketName);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 创建bucket
     *
     * @author pan
     * @date 2021/4/26
     */
    public void makeBucket(String bucketName){

        try {
            if(bucketExists(bucketName)){
                throw new DynamicException(bucketName+"已存在");
            }
            minioClient.makeBucket(bucketName);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 使用默认的存储桶bucket
     *
     * @author pan
     * @date 2021/4/26
     */
    public String useDefaultBucket(String bucketName){
        if(StringUtils.isBlank(bucketName)){
            bucketName=minIoProperties.getBucketName();
        }
        return bucketName;
    }

    /**
     * 上传文件（地址方式）
     * @param bucketName 存储桶名称
     * @param objectName 保存在存储桶的文件
     * @param filename 文件+路径
     * @return 文件保存位置
     */
    @SneakyThrows
    public String uploadFile(String bucketName,String objectName,String filename){
        //如果存储桶为空，则使用默认的
        bucketName = useDefaultBucket(bucketName);
        if (!this.bucketExists(bucketName)) {
            throw new DynamicException(bucketName + "存储桶不存在");
        }
        minioClient.putObject(bucketName,objectName,filename,null);
        return objectName;
    }

    /**
     * 上传文件
     * @param bucketName 存储桶名称
     * @param objectName 保存在存储桶的文件
     * @param multipartFile 文件流
     * @return 文件保存位置
     */
    @SneakyThrows
    public String uploadFile(String bucketName, String objectName, MultipartFile multipartFile){
        //如果存储桶为空，则使用默认的
        bucketName = useDefaultBucket(bucketName);
        if (!this.bucketExists(bucketName)) {
            throw new DynamicException(bucketName + "存储桶不存在");
        }
        InputStream inputStream=multipartFile.getInputStream();
        PutObjectOptions putObjectOptions=new PutObjectOptions(multipartFile.getSize(),-1L);
        minioClient.putObject(bucketName,objectName,inputStream,putObjectOptions);
        return objectName;
    }

    /**
     * 删除文件
     * @param bucketName 存储桶名称
     * @param objectName 保存在存储桶的文件
     * @return 文件保存位置
     */
    @SneakyThrows
    public String deleteFile(String bucketName, String objectName){
        bucketName = useDefaultBucket(bucketName);
        if (!this.bucketExists(bucketName)) {
            throw new DynamicException(bucketName + "存储桶不存在");
        }
        minioClient.removeObject(bucketName,objectName);
        return objectName;
    }

    /**
     * 下载文件
     * @param bucketName 存储桶名称
     * @param objectName 保存在存储桶的文件
     * @param fileName 文件保存位置
     * @return 文件保存位置
     */
    @SneakyThrows
    public String downloadFile(String bucketName, String objectName,String fileName){
        bucketName = useDefaultBucket(bucketName);
        if (!this.bucketExists(bucketName)) {
            throw new DynamicException(bucketName + "存储桶不存在");
        }
        minioClient.getObject(bucketName,objectName,fileName);
        return fileName;
    }

    /**
     * 下载文件
     * @param bucketName 存储桶名称
     * @param objectName 保存在存储桶的文件
     * @return 文件保存位置
     */
    @SneakyThrows
    public InputStream downloadFile(String bucketName, String objectName){
        bucketName = useDefaultBucket(bucketName);
        if (!this.bucketExists(bucketName)) {
            throw new DynamicException(bucketName + "存储桶不存在");
        }
        return minioClient.getObject(bucketName,objectName);
    }
}


新版工具类
MinIoUtil
package cn.emd.platform.common.file.util;

import cn.emd.platform.common.core.exception.DynamicException;
import cn.emd.platform.common.file.config.MinIoProperties;
import io.minio.*;
import lombok.SneakyThrows;
import org.apache.commons.lang3.StringUtils;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.PostConstruct;
import java.io.InputStream;

/**
 * MinIo工具类
 *
 * @author pan
 * @date 2021/4/27
 */
@Component
@Configuration
@EnableConfigurationProperties(MinIoProperties.class)
public class MinIoUtil {

    private MinIoProperties minIoProperties;
    private MinioClient minioClient;

    public MinIoUtil(MinIoProperties minIoProperties){
        this.minIoProperties=minIoProperties;
    }

    @PostConstruct
    public void init(){

        minioClient=MinioClient.builder()
                .endpoint(minIoProperties.getEndpoint())
                .credentials(minIoProperties.getAccessKey(),minIoProperties.getSecretKey())
                .build();
        //创建默认一个bucket,即存储桶
        try {
            boolean found =this.bucketExists(minIoProperties.getBucketName());
            if (!found) {
                this.makeBucket(minIoProperties.getBucketName());
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    /**
      * 判断是否存在 bucket
      * @param bucketName 存储桶
      * @return 存在true,不存在false
      */
    public Boolean bucketExists(String bucketName){

        try {
            return minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 创建bucket
     *
     * @author pan
     * @date 2021/4/26
     */
    public void makeBucket(String bucketName){

        try {
            if(this.bucketExists(bucketName)){
                throw new DynamicException(bucketName+"已存在");
            }
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 使用默认的存储桶bucket
     *
     * @author pan
     * @date 2021/4/26
     */
    public String useDefaultBucket(String bucketName){
        if(StringUtils.isBlank(bucketName)){
            bucketName=minIoProperties.getBucketName();
        }
        return bucketName;
    }

    /**
     * 上传文件（浏览器方式）
     *
     * @param bucketName    存储桶名称
     * @param objectName    保存在存储桶的文件
     * @param multipartFile 文件流
     * @return 文件保存位置
     */
    @SneakyThrows
    public String uploadFile(String bucketName, String objectName, MultipartFile multipartFile) {
        //如果存储桶为空，则使用默认的
        bucketName=useDefaultBucket(bucketName);
        if (!this.bucketExists(bucketName)) {
            throw new DynamicException(bucketName + "存储桶不存在");
        }
        InputStream inputStream = multipartFile.getInputStream();
        minioClient.putObject(PutObjectArgs.builder()
                .bucket(bucketName)
                .object(objectName)
                .stream(inputStream,multipartFile.getSize(),-1L)
                .build());
        return objectName;
    }

    /**
     * 上传文件(地址方式)
     *
     * @param bucketName    存储桶名称
     * @param objectName    保存在存储桶的文件
     * @param filename 文件地址
     * @return 文件保存位置
     */
    @SneakyThrows
    public String uploadFile(String bucketName, String objectName, String filename) {
        //如果存储桶为空，则使用默认的
        bucketName = useDefaultBucket(bucketName);
        if (!this.bucketExists(bucketName)) {
            throw new DynamicException(bucketName + "存储桶不存在");
        }
        minioClient.uploadObject(UploadObjectArgs.builder()
                .bucket(bucketName)
                .object(objectName)
                .filename(filename)
                .build()
        );
        return objectName;
    }

    /**
     * 下载文件
     *
     * @param bucketName 存储桶名称
     * @param objectName 保存在存储桶的文件
     * @param fileName   文件保存位置
     * @return 文件保存位置
     */
    @SneakyThrows
    public String downloadFile(String bucketName, String objectName, String fileName) {
        bucketName = useDefaultBucket(bucketName);
        if (!this.bucketExists(bucketName)) {
            throw new DynamicException(bucketName + "存储桶不存在");
        }
        minioClient.downloadObject(DownloadObjectArgs.builder()
                .bucket(bucketName)
                .object(objectName)
                .filename(fileName)
                .build()
        );
        return fileName;
    }

    /**
     * 下载文件
     *
     * @param bucketName 存储桶名称
     * @param objectName 保存在存储桶的文件
     * @return 文件流
     */
    @SneakyThrows
    public InputStream downloadFile(String bucketName, String objectName) {
        bucketName = useDefaultBucket(bucketName);
        if (!this.bucketExists(bucketName)) {
            throw new DynamicException(bucketName + "存储桶不存在");
        }
        InputStream inputStream=minioClient.getObject(GetObjectArgs.builder()
                .bucket(bucketName)
                .object(objectName)
                .build()
        );
        return inputStream;
    }


    /**
     * 删除文件
     *
     * @param bucketName 存储桶名称
     * @param objectName 保存在存储桶的文件
     * @return 文件保存位置
     */
    @SneakyThrows
    public String deleteFile(String bucketName, String objectName) {
        bucketName = useDefaultBucket(bucketName);
        if (!this.bucketExists(bucketName)) {
            throw new DynamicException(bucketName + "存储桶不存在");
        }
        minioClient.removeObject(RemoveObjectArgs.builder()
                .bucket(bucketName)
                .object(objectName)
                .build());
        return objectName;
    }

}
小生有礼了哈
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
minio最新版windows版本
09-17
最新版的minio文件，官网下载太慢了，提供给大家下载 MinIO 是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几kb到最大5T不等。 MinIO是一个非常轻量的服务,可以很简单的和其他应用的结合，类似 NodeJS, Redis 或者 MySQL。
minio 安装部署包 + 部署文档
03-21
minio 安装部署包 + 部署文档（单机+集群）
Rocky Linux 9.3 安装 MinIO 最新版本 （超级详细版本）
好技术，多分享
12-21 1306
根据自己的操作系统找到对应的版本我这里安装的是linux-amd64运行以下 curl 命令将 MinIO 的二进制文件下载到“现在通过下面的 chmod 命令使 MinIO 二进制文件可执行为确保您可以执行 MinIO 二进制文件，您应该将 '' 目录添加到**$PATH**环境变量中。（默认PATH是有的，执行命令查看 echo $PATH）查看版本。
【实战指南】Spring Boot集成Minio：快速实现对象存储服务
kiingking的博客
07-13 203
在Spring Boot中集成Minio可以让你的应用程序具备对象存储的功能，这非常适合处理大量的非结构化数据。
Docker-compose 安装Minio 最新版本
Gblfy_Blog
09-21 1683
文章目录一、环境准备1.安装docker-compose2. 新版本尝鲜3. 镜像下载二、单机编排2.1. 创建docker-compose.yaml2.2. 运行三、集群编排3.1. 下载docker-compose.yaml3.2. nginx.conf3.3.运行 一、环境准备 1.安装docker-compose https://gblfy.blog.csdn.net/article/details/113934554 2. 新版本尝鲜 minio在升级之后，部署文件有了改动。之前web页面和api
docker-compose安装最新版本minio(2023版本)
Lc_2018的博客
04-19 2662
使用docker-compose安装2023最新版minio
使用最新版本的minio问题,寻求解决
zgdva的博客
05-24 512
新版本的minio 我不会使用
MinIO部署文件、文档
07-26
2. S3兼容性：MinIO支持Amazon S3 API，这意味着你可以使用任何S3兼容的客户端或者工具来访问和操作MinIO存储的数据。 二、MinIO的部署方式 1. 单节点部署：适合测试和开发环境，只需一个服务器或虚拟机即可运行...
minio老版本端口分开
09-14
minio老版本端口分开
minio分布式部署搭建文档及安装程序
02-16
MinIO是一款开源的对象存储服务，它适用于云环境和本地部署，尤其在大数据、人工智能和容器化应用中广泛应用。本文将详细讲解如何进行MinIO的分布式部署，并简要介绍其安装过程。 **一、MinIO分布式部署** 分布式...
MinIO通用上传工具类
最新发布
07-25
MinIO通用上传工具类
linux-amd64-minio
02-28
linux-amd64环境运行， 版本号: RELEASE.2019-02-26T19-51-46Z， 具体使用方式参考博客: https://blog.csdn.net/justlpf/article/details/87857254
linux查看minio版本命令及链接.txt
09-05
linux查看minio版本
linux版minio未加密最新版本V20220526
02-02
linux版本，minio文件不加密可用的最新版本V20220526
minio-RELEASE.2023-01-31T02-24-19Z版本
02-08
新版本配置 export MINIO_ROOT_USER=admin export MINIO_ROOT_PASSWORD=12345678 原旧版本中的配置是MINIO_ACCESS_KEY和MINIO_SECRET_KEY，请注意别在各博客中直接复制把自己的配置写错了，新下载的minio是用不了旧配置滴。
文件存储minio-RELEASE.2021-04-22T15-44-28Z历史老旧版本windows-linux下载
12-06
minio-RELEASE.2021-04-22T15-44-28Z，这是MinIO最后一个 Apache V2.0的版本，minio此后的版本都改为AGPLV3协议了，没法进行商业用途了。这个包包含minio-RELEASE.2021-04-22T15-44-28Z的windows二进制包，linux二进制包及源代码，可放心下载。
minio最新版本(2022.10.31)简易集群搭建（详细到爆）
Q_W_W_Q的博客
11-15 5966
解决minio集群搭建问题
centos7 用docker 下载minio最新版
New__Horizons的博客
11-13 1069
centos7使用docker安装最新版minio
2024年4月，docker启动新版minio
luzhe3014151的专栏
04-22 647
最新版minio容器启动。
minio上传图片工具类
07-12
你可以使用以下的Python代码来创建一个Minio上传图片的工具类： ```python from minio import Minio from minio.error import ResponseError class MinioUploader: def __init__(self, endpoint, access_key, secret_key, bucket_name): self.endpoint = endpoint self.access_key = access_key self.secret_key = secret_key self.bucket_name = bucket_name def upload_image(self, file_path, object_name): try: minio_client = Minio(self.endpoint, access_key=self.access_key, secret_key=self.secret_key, secure=False) # 检查bucket是否存在，不存在则创建 if not minio_client.bucket_exists(self.bucket_name): minio_client.make_bucket(self.bucket_name) # 上传图片 minio_client.fput_object(self.bucket_name, object_name, file_path) return True, "Image uploaded successfully" except ResponseError as err: return False, f"Error uploading image: {err}" ``` 使用时，你需要提供Minio服务的endpoint、access_key、secret_key以及bucket_name。然后，你可以调用`upload_image`方法来上传图片。该方法接收两个参数：`file_path`表示本地图片文件的路径，`object_name`表示在Minio中保存的对象名称。 以下是一个使用示例： ```python minio_uploader = MinioUploader(endpoint='minio.example.com', access_key='your-access-key', secret_key='your-secret-key', bucket_name='your-bucket-name') success, message = minio_uploader.upload_image('/path/to/image.jpg', 'image.jpg') if success: print(message) else: print(f"Error: {message}") ``` 请确保已经安装了`minio`库，可以使用`pip install minio`来进行安装。此外，根据你实际的Minio配置，需要修改代码中的相关参数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小生有礼了哈

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值