docker安装Minio

已于 2024-08-25 00:08:32 修改
阅读量1.2k 收藏 18
点赞数 20
分类专栏： minio 文章标签： docker 容器 minio
于 2024-07-25 16:03:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26709459/article/details/140691183
版权

docker安装Minio

  • 一、docker安装minio
    • 1、拉取镜像
    • 2、启动镜像
      • (1)http启动
      • (2)https启动
  • 二、SpringBoot集成minio
    • 1、整合前准备
    • 2、代码整合
      • (1)导入maven做标
      • (2)配置application.yml
      • (3)添加配置类
      • (4)自定义工具类

一、docker安装minio

1、拉取镜像

docker pull minio/minio

在这里插入图片描述

2、启动镜像

(1)http启动

创建相关数据目录

mkdir -p /wz_conf/minio/data
mkdir -p /wz_conf/minio/config

docker run -d \
  --name my_minio \
  -p 9000:9000 \
  -p 9001:9001 \
  -v /wz_conf/minio/data:/data \
  -v /wz_conf/minio/config:/root/.minio \
  -e MINIO_ROOT_USER=admin \
  -e MINIO_ROOT_PASSWORD=admin \
  minio/minio server /data --console-address ":9001"

说明：

  • -v /wz_conf/minio/data:/data 挂载数据目录
  • -v /wz_conf/minio/config:/root/.minio 挂载配置目录
  • -e MINIO_ROOT_USER=admin 配置登陆用户名
  • -e MINIO_ROOT_PASSWORD=admin 配置登陆密码
  • –console-address “:9001” 服务端口为9001

访问： http://ip:9001
在这里插入图片描述

(2)https启动

这里使用自签名证书：

openssl genrsa -out /wz_conf/server.key 2048  

openssl req -new -key /wz_conf/server.key -out /wz_conf/server.csr  

openssl x509 -req -days 365 -in /wz_conf/server.csr -signkey /wz_conf/server.key -out /wz_conf/server.crt

启动命令如下：

docker run -d \
  --name my_minio \
  -p 9000:9000 \
  -p 9001:9001 \
  -v /wz_conf/minio/data:/data \
  -v /wz_conf/minio/config:/root/.minio \
  -v /wz_conf/server.crt:/root/.minio/certs/public.crt \
  -v /wz_conf/server.key:/root/.minio/certs/private.key \
  -e MINIO_ROOT_USER=admin \
  -e MINIO_ROOT_PASSWORD=admin \
  -e MINIO_HTTPS_CERT_FILE=/root/.minio/certs/public.crt \
  -e MINIO_HTTPS_KEY_FILE=/root/.minio/certs/private.key \
  minio/minio server /data --console-address ":9001"

访问： https://ip:9001

至此，安装完成！

更多详细说明可以查阅官方说明：
minio官方文档

二、SpringBoot集成minio

1、整合前准备

创建用户：
在这里插入图片描述
创建组
在这里插入图片描述
创建accessKey和secretKey，使用代码连接是需要用到，注意保存好
在这里插入图片描述
创建Bucket，代码中自行创建也可以
在这里插入图片描述

2、代码整合

(1)导入maven做标

<dependency>
    <groupId>io.minio</groupId>
    <artifactId>minio</artifactId>
    <version>8.5.2</version>
</dependency>

(2)配置application.yml

spring:
  minio:
    access-key: *****************************
    secret-key: *****************************
    url: https://ip:9000
    bucket-name: ******

(3)添加配置类

注：由于这里使用的自签名证书，minio使用https连接api会出现如下错误，这里在配置中忽略证书验证。

PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target

配置类如下，这里兼容了http与https两个形式的连接：

import io.minio.MinioClient;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import okhttp3.OkHttpClient;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.security.cert.X509Certificate;

@Data
@Configuration
@ConfigurationProperties(prefix = "spring.minio")
@Slf4j
public class MinioConfig {
    private String accessKey;

    private String secretKey;

    private String url;

    private String bucketName;

    @Bean
    public MinioClient minioClient() {
        if(url.startsWith("https")) {
            TrustManager[] trustAllCerts = new TrustManager[]{
                    new X509TrustManager() {
                        public X509Certificate[] getAcceptedIssuers() {
                            return new X509Certificate[0];
                        }

                        public void checkClientTrusted(X509Certificate[] certs, String authType) {
                        }

                        public void checkServerTrusted(X509Certificate[] certs, String authType) {
                        }
                    }
            };
            SSLContext sslContext = null;
            try {
                sslContext = SSLContext.getInstance("SSL");
                sslContext.init(null, trustAllCerts, new java.security.SecureRandom());
            } catch (Exception e) {
                log.error("Install the all-trusting trust manager error:{}", e.getMessage());
            }
            OkHttpClient customHttpClient = new OkHttpClient.Builder()
                    .sslSocketFactory(sslContext.getSocketFactory(), (X509TrustManager) trustAllCerts[0])
                    .hostnameVerifier((hostname, session) -> true)
                    .build();
            return MinioClient.builder()
                    .endpoint(url)
                    .credentials(accessKey, secretKey)
                    .httpClient(customHttpClient)
                    .build();
        } else {
            return MinioClient.builder()
                    .endpoint(url)
                    .credentials(accessKey, secretKey)
                    .build();
        }
    }
}

(4)自定义工具类

import cn.hutool.core.io.FastByteArrayOutputStream;
import com.webuild.ai.config.MinioConfig;
import com.webuild.common.core.util.U;
import io.minio.*;
import io.minio.errors.*;
import io.minio.http.Method;
import io.minio.messages.Bucket;
import io.minio.messages.Item;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

@Component
@Slf4j
public class MinioUtils {

    @Autowired
    private MinioClient minioClient;
    @Autowired
    private MinioConfig minioConfig;

    /**
     * 判断bucket是否存在，不存在则创建
     *
     * @Description
     * @Param bucketName bucket名称
     * @Return java.lang.Boolean
     * @Author Administrator
     * @Date 2024/7/17 14:31
     **/
    public Boolean bucketExists(String bucketName) throws ServerException, InsufficientDataException, ErrorResponseException, IOException, NoSuchAlgorithmException, InvalidKeyException, InvalidResponseException, XmlParserException, InternalException {
        boolean exists = false;
        exists = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
        if (!exists) {
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
            exists = true;
        }
        return exists;
    }

    /**
     * 创建存储bucket
     *
     * @Description
     * @Param bucketName
     * @Return java.lang.Boolean
     * @Author Administrator
     * @Date 2024/7/17 14:42
     **/
    public Boolean makeBucket(String bucketName, String directoryPath) throws ServerException, InsufficientDataException, ErrorResponseException, IOException, NoSuchAlgorithmException, InvalidKeyException, InvalidResponseException, XmlParserException, InternalException {
        minioClient.makeBucket(MakeBucketArgs.builder()
                .bucket(bucketName)
                .build());

        return true;
    }

    /**
     * 删除存储bucket
     *
     * @Description
     * @Param bucketName
     * @Return java.lang.Boolean
     * @Author Administrator
     * @Date 2024/7/17 14:44
     **/
    public Boolean removeBucket(String bucketName) throws ServerException, InsufficientDataException, ErrorResponseException, IOException, NoSuchAlgorithmException, InvalidKeyException, InvalidResponseException, XmlParserException, InternalException {
        minioClient.removeBucket(RemoveBucketArgs.builder()
                .bucket(bucketName)
                .build());
        return true;
    }

    /**
     * 获取全部bucket
     *
     * @Description
     * @Return java.util.List<io.minio.messages.Bucket>
     * @Author Administrator
     * @Date 2024/7/17 14:44
     **/
    public List<Bucket> getAllBuckets() throws ServerException, InsufficientDataException, ErrorResponseException, IOException, NoSuchAlgorithmException, InvalidKeyException, InvalidResponseException, XmlParserException, InternalException {
        return minioClient.listBuckets();
    }

    /**
     * 上传文件
     *
     * @Description
     * @Param bucketName
     * @Param prefix
     * @Param file
     * @Return java.lang.String
     * @Author Administrator
     * @Date 2024/7/17 14:51
     **/
    public String upload(String bucketName, String prefix, MultipartFile file) throws IOException, ServerException, InsufficientDataException, ErrorResponseException, NoSuchAlgorithmException, InvalidKeyException, InvalidResponseException, XmlParserException, InternalException {
        String originalFilename = file.getOriginalFilename();
        if (StringUtils.isBlank(originalFilename)) {
            throw new RuntimeException();
        }
        boolean fileExists;
        try {
            fileExists = isFileExists(bucketName, prefix, originalFilename);
        } catch (Exception e) {
            fileExists = false;
        }
        if(fileExists) {
            log.info("当前文件存在同名文件,开始重命名保存. originalFilename={}", originalFilename);
            int dotIndex = originalFilename.lastIndexOf('.');
            // 获取不带后缀名的文件名
            String fileNameWithoutExtension = originalFilename.substring(0, dotIndex);
            // 获取文件后缀名
            String fileExtension = originalFilename.substring(dotIndex + 1);
            originalFilename = fileNameWithoutExtension + "_" + System.currentTimeMillis() + "." + fileExtension;
        }
        String objectName = U.isBlank(prefix) ? originalFilename : "/" + prefix + "/" + originalFilename;
        PutObjectArgs objectArgs = PutObjectArgs.builder().bucket(bucketName).object(objectName)
                .stream(file.getInputStream(), file.getSize(), -1).contentType(file.getContentType()).build();
        //文件名称相同会覆盖
        minioClient.putObject(objectArgs);
        return originalFilename;
    }

    /**
     * 上传报警图片
     *
     * @Description
     * @Param bucketName
     * @Param prefix
     * @Param suffix
     * @Param fileBytes
     * @Return java.lang.String
     * @Author Administrator
     * @Date 2024/7/23 16:38
     **/
    public String upload(String bucketName, String prefix, String suffix, byte[] fileBytes) throws ServerException, InsufficientDataException, ErrorResponseException, IOException, NoSuchAlgorithmException, InvalidKeyException, InvalidResponseException, XmlParserException, InternalException {
        ByteArrayInputStream inputStream = new ByteArrayInputStream(fileBytes);
        String originalFilename = UuidUtil.getUuid() + suffix;
        String objectName = U.isBlank(prefix) ? originalFilename : "/" + prefix + "/" + originalFilename;
        PutObjectArgs objectArgs = PutObjectArgs.builder().bucket(bucketName).object(objectName)
                .stream(inputStream, fileBytes.length, -1).build();
        //文件名称相同会覆盖
        minioClient.putObject(objectArgs);
        return originalFilename;
    }

    /**
     * 预览(预览链接默认7天后过期)
     *
     * @Description
     * @Param bucketName
     * @Param fileName
     * @Return java.lang.String
     * @Author Administrator
     * @Date 2024/7/17 14:54
     **/
    public String preview(String bucketName, String prefix, String fileName) throws ServerException, InsufficientDataException, ErrorResponseException, IOException, NoSuchAlgorithmException, InvalidKeyException, InvalidResponseException, XmlParserException, InternalException {
        // 查看文件地址
        String objectName = U.isBlank(prefix) ? fileName : "/" + prefix + "/" + fileName;
        GetPresignedObjectUrlArgs build = GetPresignedObjectUrlArgs.builder().bucket(bucketName).object(objectName).method(Method.GET).build();
        return minioClient.getPresignedObjectUrl(build);
    }

    /**
     * 下载文件
     *
     * @Description
     * @Param bucketName
     * @Param fileName
     * @Param res
     * @Return void
     * @Author Administrator
     * @Date 2024/7/17 14:56
     **/
    public void download(String bucketName, String prefix, String fileName, HttpServletResponse res) {
        String objectName = U.isBlank(prefix) ? fileName : "/" + prefix + "/" + fileName;
        GetObjectArgs objectArgs = GetObjectArgs.builder().bucket(bucketName).object(objectName).build();
        try (GetObjectResponse response = minioClient.getObject(objectArgs)) {
            byte[] buf = new byte[1024];
            int len;
            try (FastByteArrayOutputStream os = new FastByteArrayOutputStream()) {
                while ((len = response.read(buf)) != -1) {
                    os.write(buf, 0, len);
                }
                os.flush();
                byte[] bytes = os.toByteArray();
                res.setCharacterEncoding("utf-8");
                // 设置强制下载不打开
                // res.setContentType("application/force-download");
                res.addHeader("Content-Disposition", "attachment;fileName=" + fileName);
                try (ServletOutputStream stream = res.getOutputStream()) {
                    stream.write(bytes);
                    stream.flush();
                }
            }
        } catch (Exception e) {
            log.error("下载文件异常. e={}", e);
        }
    }

    /**
     * 查看文件对象
     *
     * @Description
     * @Param bucketName
     * @Return java.util.List<io.minio.messages.Item>
     * @Author Administrator
     * @Date 2024/7/17 15:32
     **/
    public List<Item> listObjects(String bucketName) throws ServerException, InsufficientDataException, ErrorResponseException, IOException, NoSuchAlgorithmException, InvalidKeyException, InvalidResponseException, XmlParserException, InternalException {
        Iterable<Result<Item>> results = minioClient.listObjects(
                ListObjectsArgs.builder().bucket(bucketName).build());
        List<Item> items = new ArrayList<>();
        for (Result<Item> result : results) {
            items.add(result.get());
        }
        return items;
    }

    /**
     * 删除文件
     *
     * @Description
     * @Param bucketName
     * @Param fileName
     * @Return boolean
     * @Author Administrator
     * @Date 2024/7/17 15:32
     **/
    public boolean remove(String bucketName, String prefix, String fileName) throws ServerException, InsufficientDataException, ErrorResponseException, IOException, NoSuchAlgorithmException, InvalidKeyException, InvalidResponseException, XmlParserException, InternalException {
        String objectName = U.isBlank(prefix) ? fileName : "/" + prefix + "/" + fileName;
        minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(objectName).build());
        return true;
    }

    /**
     * 生成一个带到期时间、签名的URL，这个地址可以提供给没有登录的第三方共享访问或者上传对象，针对于Bucket为私有的情况
     * 
     * @Description 
     * @Param bucketName
     * @Param fileName
     * @Return java.lang.String
     * @Author Administrator
     * @Date 2024/7/17 16:22     
     **/
    public String getPresignedObjectUrl(String bucketName, String prefix, String fileName) throws ServerException, InsufficientDataException, ErrorResponseException, IOException, NoSuchAlgorithmException, InvalidKeyException, InvalidResponseException, XmlParserException, InternalException {
        String objectName = U.isBlank(prefix) ? fileName : "/" + prefix + "/" + fileName;
        return minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
                .bucket(bucketName)
                .object(objectName)
                // 设置过期时间，30分钟
                .expiry(30, TimeUnit.MINUTES)
                .method(Method.GET)
                .build());
    }

    /**
     * 判断文件是否存在
     * 
     * @Description 
     * @Param bucketName
     * @Param prefix
     * @Param fileName
     * @Return boolean
     * @Author Administrator
     * @Date 2024/7/22 17:42     
     **/
    public boolean isFileExists(String bucketName, String prefix, String fileName) throws ServerException, InsufficientDataException, ErrorResponseException, IOException, NoSuchAlgorithmException, InvalidKeyException, InvalidResponseException, XmlParserException, InternalException {
        String objectName = U.isBlank(prefix) ? fileName : "/" + prefix + "/" + fileName;
        minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build());
        return true;
    }
}

到此就可以通过自己的工具类使用minio了…

GreaterBuilder
关注
  • 20
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Docker安装MinIO教程
猿小白的博客
05-20 2360
本章教程，主要介绍一下，如何在Linux用Docker安装MinIO。MinIO是一个高性能、分布式对象存储系统，支持S3 API，适用于云原生环境。MinIO可以在标准硬件上运行，并且具有低延迟、高吞吐量、高可用性和可扩展性等优势。MinIO使用Erasure Code技术实现数据冗余和恢复，以确保数据的安全性和可靠性。MinIO还支持多租户、数据加密、访问控制等功能，可以满足企业级应用的需求。
docker安装minio以及踩坑
最新发布
DN金猿的博客
06-20 132
Minio 是 GlusterFS 创始人之一 Anand Babu Periasamy 发布新的开源项目。Minio 兼容 Amason 的 S3 分布式对象存储项目，采用 Golang 实现，客户端支持 Java,Python,Javacript, Golang 语言。Minio 可以做为云存储的解决方案用来保存海量的图片，视频，文档。由于采用 Golang 实现，服务端可以工作在 Windows,Linux, OS X 和 FreeBSD 上。配置简单，基本是复制可执行程序，单行命令可以运行起来。
docker安装minio
qq_43049583的博客
04-08 366
docker安装minio
在Docker中安装Minio
linder_leader的专栏
04-03 1858
在Docker中安装Minio
Docker安装MinIO
packge的博客
12-23 3429
1、MinIO 是在 Apache License v2.0 下发布的对象存储服务器。它与 Amazon S3 云存储服务兼容。它最适合存储非结构化数据，如照片，视频，日志文件，备份和容器/ VM 映像。对象的大小可以从几 KB 到最大 5TB。2、MinIO 服务器足够轻，可以与应用程序堆栈捆绑在一起，类似于 NodeJS，Redis 和 MySQL3 一种高性能的分布式对象存储服务器，用于大型数据基础设施。它是机器学习和其他大数据工作负载下Hadoop HDFS 的理想 s3 兼容替代品。
docker 安装 minio
我的名字叫大白
03-14 2914
Docker安装Minio
Docker安装minio
McOldLiu的博客
04-12 1131
-v` 参数指定数据持久化的目录，这里我们将容器内的 `/data` 目录映射到本地的 `/mnt/data` 目录中；在浏览器中输入 `http://localhost:9000`，并使用之前设置的 ACCESS\_KEY 和 SECRET\_KEY 进行登录。如果能够正常登录，并且在 Web 界面上看到 MinIO 的管理页面，则表明 MinIO 已经成功安装，并且运行正常。Minio拥有轻量级、高效率、易部署等特点，可用于各种应用场景，如备份、存档、容器存储、媒体存储等。
Docker 安装 MinIO
sinat_25849999的博客
06-01 663
主要记录在centos当中安装MinIO
Linux 使用 docker 安装 MinIO 分布式对象存储系统
lpyun@aliyun.com
03-13 782
Minio 是一个基于 Apache License v2.0 开源协议的对象存储服务。它兼容亚马逊 S3 云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几 kb 到最大 5T 不等。MinIO 官网。
基于Docker安装minio【保姆级教程、内含图解】
Acloasia的博客
07-12 6498
基于Docker安装minio【保姆级教程、内含图解】
Docker 安装Minio
zhouzhiwengang的专栏
08-04 1197
Docker 安装Minio
【Docker】手把手教你在windows使用Docker安装Minio[详细教程]
m0_64210833的博客
06-15 4925
手把手教你在windows使用Docker安装Minio[详细教程]
Docker安装Minio
Ark方舟
07-08 537
docker 安装 Minio （含分享链接无法访问的问题）
docker拉取minio
03-20
的命令是什么？ 您可以使用以下命令拉取minio镜像： docker pull minio/minio 然后，您可以使用以下命令启动minio容器： docker run -p 9000:9000 minio/minio server /data 这将在本地主机的9000端口上启动minio服务器，并将数据存储在容器的/data目录中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值