minio简单搭建使用

已于 2022-11-03 17:31:28 修改
阅读量1.3k 收藏 2
点赞数
文章标签： windows 后端
于 2020-11-13 11:18:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wenjian9487/article/details/109671108
版权

1.minio下载

windods
https://docs.min.io/cn/minio-quickstart-guide.html
linux
minio
http://dl.minio.org.cn/server/minio/release/linux-amd64/minio
mc
http://dl.minio.org.cn/client/mc/release/linux-amd64/mc

linxu安装

chmod +x minio
./minio server /usr/local/minio/data #关闭后Minio也会关闭
nohup /usr/local/minio/minio server  /usr/local/minio/data > /usr/local/minio/data/minio.log 2>&1 & #后台启动

docker 安装minio

#获取镜像
docker pull minio/minio
#在服务器上创建minio文件上传目录
mkdir -p /data/docker/minio
#修改挂载目录权限
chown -R 1000:1000 /data/docker/minio
chmod -R 755 /data/docker/minio
#启动服务 
docker run -d -p 9000:9000 -p 9001:9001 --restart=always --privileged=true --name minio -e "MINIO_ROOT_USER=minio"  -e "MINIO_ROOT_PASSWORD=miniotest" -v /data/docker/minioFiles:/data minio/minio server /data --console-address ":9001"

在Windows下将minio注册为本地服务

通过winsw注册服务的方式，把minio注册成服务运行

  1. 下载 https://github.com/winsw/winsw/releases
  2. 将WinSW.NET461.exe更名为minio-server.exe
  3. 同目录下创建minio-server.xml。特别注意，xml和exe必须同名
  4. 配置minio-server.xml文件
  5. 使用minio-server.exe install安装服务
  6. 安装完后，去服务中启动服务。
    minio-server.exe uninstall卸载服务
<service>
    <id>minio-server</id>
    <name>minio-server</name>
    <description>minio文件存储服务器</description>
    <!-- 可设置环境变量 -->
    <env name="HOME" value="%BASE%"/>
    <executable>%BASE%\minio.exe</executable>
    <arguments>server "%BASE%\data"</arguments>
    <!-- <logmode>rotate</logmode> -->
    <logpath>%BASE%\logs</logpath>
    <log mode="roll-by-size-time">
      <sizeThreshold>10240</sizeThreshold>
      <pattern>yyyyMMdd</pattern>
      <autoRollAtTime>00:00:00</autoRollAtTime>
      <zipOlderThanNumDays>5</zipOlderThanNumDays>
      <zipDateFormat>yyyyMMdd</zipDateFormat>
    </log>
</service>

在这里插入图片描述
访问地址：127.0.0.1:9000
accessKey: minioadmin
secretKey: minioadmin

SpringBoot 集成MinIO

jar包

        <!-- 访问图片服务器 -->
        <dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <version>7.0.2</version>
        </dependency>

@Getter
@Setter
@NoArgsConstructor
@ConfigurationProperties(prefix ="minio")
public class MinioConfig {
    @ApiModelProperty("endPoint是一个URL，域名，IPv4或者IPv6地址")
    private String endpoint;

    @ApiModelProperty("TCP/IP端口号")
    private int port;

    @ApiModelProperty("accessKey类似于用户ID，用于唯一标识你的账户")
    private String accessKey;

    @ApiModelProperty("secretKey是你账户的密码")
    private String secretKey;

    @ApiModelProperty("如果是true，则用的是https而不是http,默认值是true")
    private Boolean secure;

    @ApiModelProperty("默认存储桶")
    private String bucketName;
    @Bean

    public MinioClient getMinioClient() throws InvalidPortException, InvalidEndpointException {
         //MinioClient.endpoint(endpoint,port,secure).credentials(accessKey,secretKey).build()
        MinioClient minioClient = new MinioClient(endpoint,port,accessKey,secretKey,secure) ;
        return minioClient;
    }

@Configuration
public class MinioUtil {
    @Autowired
    MinioClient minioClient;

    private static final int DEFAULT_EXPIRY_TIME = 7 * 24 * 3600;
    public MinioUtil() {
    }

    private static class MinioUtilHoler {
        private static MinioUtil INSTANCE = new MinioUtil();
    }

    public static MinioUtil getInstance() {
        return MinioUtilHoler.INSTANCE;
    }

    /**
     * 检查桶是否存在
     */
    @SneakyThrows
    public boolean bucketExists(String bucketName) {
        return minioClient.bucketExists(bucketName);
    }

    /**
     * 创建储存桶
     */
    @SneakyThrows
    public boolean makeBucket(String bucketName) {
        if (!bucketExists(bucketName)) {
            minioClient.makeBucket(bucketName);
            //设置桶的权限
            StringBuilder builder = new StringBuilder();
            builder.append("{\n");
            builder.append("    \"Statement\": [\n");
            builder.append("        {\n");
            builder.append("            \"Action\": [\n");
            builder.append("                \"s3:GetBucketLocation\",\n");
            builder.append("                \"s3:ListBucket\"\n");
            builder.append("            ],\n");
            builder.append("            \"Effect\": \"Allow\",\n");
            builder.append("            \"Principal\": \"*\",\n");
            builder.append("            \"Resource\": \"arn:aws:s3:::"+bucketName+"\"\n");
            builder.append("        },\n");
            builder.append("        {\n");
            builder.append("            \"Action\": \"s3:GetObject\",\n");
            builder.append("            \"Effect\": \"Allow\",\n");
            builder.append("            \"Principal\": \"*\",\n");
            builder.append("            \"Resource\": \"arn:aws:s3:::"+bucketName+"/*\"\n");
            builder.append("        }\n");
            builder.append("    ],\n");
            builder.append("    \"Version\": \"2012-10-17\"\n");
            builder.append("}\n");
            minioClient.setBucketPolicy(bucketName,builder.toString());
            return true;
        }
        return false;
    }

    /**
     * 查询所有桶名称
     */
    @SneakyThrows
    public List<String> listBucketNames() {
        List<Bucket> bucketList = listBuckets();
        List<String> bucketNameList = bucketList.stream().map(Bucket::name).collect(Collectors.toList());
        return bucketNameList;
    }

    /**
     * 查询所有储存桶
     */
    @SneakyThrows
    public List<Bucket> listBuckets() {
        return minioClient.listBuckets();
    }

    /**
     * 删除储存桶
     */
    @SneakyThrows
    public boolean removeBucket(String bucketName) {
        boolean flag = bucketExists(bucketName);
        if (flag) {
            Iterable<Result<Item>> listObjects = listObjects(bucketName);
            for (Result<Item> result : listObjects) {
                Item item = result.get();
                if (item.size() > 0) {
                    return false;
                }
            }
            //删除储存桶 只有储存桶为空时才能删除成功
            minioClient.removeBucket(bucketName);
            flag = bucketExists(bucketName);
            return !flag;
        }
        return false;
    }

    /**
     * 查询储存桶里的所有对象名称
     */
    @SneakyThrows
    public List<String> listObjectNames(String bucketName) {
        boolean flag = bucketExists(bucketName);
        List<String> listObjectNames = new ArrayList<>();
        if (flag) {
            Iterable<Result<Item>> listObjects = listObjects(bucketName);
            for (Result<Item> result : listObjects) {
                Item item = result.get();
                listObjectNames.add(item.objectName());
            }
        }
        return listObjectNames;
    }

    /**
     * 查询储存桶中的所有对象
     */
    @SneakyThrows
    public Iterable<Result<Item>> listObjects(String bucketName) {
        boolean flag = bucketExists(bucketName);
        if (flag) {
            return minioClient.listObjects(bucketName);
        }
        return null;
    }

    /**
     * 通过文件上传到对象
     */
    @SneakyThrows
    public boolean uploadObject(String bucketName, String objectName, String fileName) {
        boolean flag = bucketExists(bucketName);
        if (flag) {
            minioClient.putObject(bucketName, objectName, fileName, null);
            ObjectStat statObject = statObject(bucketName, objectName);
            if (statObject != null && statObject.length() > 0) {
                return true;
            }
        }
        return false;
    }

    /**
     * 文件上传
     */
    @SneakyThrows
    public boolean putObject(String bucketName, MultipartFile multipartFile, String filename) {
        boolean flag = bucketExists(bucketName);
        if (flag) {
            PutObjectOptions putObjectOptions = new PutObjectOptions(multipartFile.getSize(), PutObjectOptions.MIN_MULTIPART_SIZE);
            putObjectOptions.setContentType(multipartFile.getContentType());
            minioClient.putObject(bucketName, filename, multipartFile.getInputStream(), putObjectOptions);
            ObjectStat statObject = statObject(bucketName, filename);
            if (statObject != null && statObject.length() > 0) {
                return true;
            }
        }
        return false;
    }

    /**
     * 流上传
     */
    @SneakyThrows
    public boolean putObject(String bucketName, String objectName, InputStream stream) {
        boolean flag = bucketExists(bucketName);
        if (flag) {
            minioClient.putObject(bucketName, objectName, stream, new PutObjectOptions(stream.available(), -1));
            ObjectStat statObject = statObject(bucketName, objectName);
            if (statObject != null && statObject.length() > 0) {
                return true;
            }
        }
        return false;
    }

    /**
     * 流的方式获取文件
     */
    @SneakyThrows
    public InputStream getObject(String bucketName, String objectName) {
        boolean flag = bucketExists(bucketName);
        if (flag) {
            ObjectStat statObject = statObject(bucketName, objectName);
            if (statObject != null && statObject.length() > 0) {
                InputStream stream = minioClient.getObject(bucketName, objectName);
                return stream;
            }
        }
        return null;
    }

    /**
     * 流方式获取文件对象（断点下载）
     */
    @SneakyThrows
    public InputStream getObject(String bucketName, String objectName, long offset, Long length) {
        boolean flag = bucketExists(bucketName);
        if (flag) {
            ObjectStat statObject = statObject(bucketName, objectName);
            if (statObject != null && statObject.length() > 0) {
                InputStream stream = minioClient.getObject(bucketName, objectName, offset, length);
                return stream;
            }
        }
        return null;
    }

    /**
     * 下载并将文件保存到本地
     */
    @SneakyThrows
    public boolean getObject(String bucketName, String objectName, String fileName) {
        boolean flag = bucketExists(bucketName);
        if (flag) {
            ObjectStat statObject = statObject(bucketName, objectName);
            if (statObject != null && statObject.length() > 0) {
                minioClient.getObject(bucketName, objectName, fileName);
                return true;
            }
        }
        return false;
    }

    /**
     * 删除一个对象
     */
    @SneakyThrows
    public boolean removeObject(String bucketName, String objectName) {
        boolean flag = bucketExists(bucketName);
        if (flag) {
            minioClient.removeObject(bucketName, objectName);
            //获取对象的元数据
            ObjectStat statObject = statObject(bucketName, objectName);
            //没有就是删除成功
            if (statObject == null || statObject.length() == 0) {
                return true;
            }
        }
        return flag;
    }

    /**
     * 删除指定桶的多个文件对象，返回错误的对象列表 全部删除成功 返回空列表
     */
    @SneakyThrows
    public List<String> removeObject(String bucketName, List<String> objectNames) {
        List<String> deleteErrorNames = new ArrayList<>();
        boolean flag = bucketExists(bucketName);
        if (flag) {
            Iterable<Result<DeleteError>> results = minioClient.removeObjects(bucketName, objectNames);
            for (Result<DeleteError> result : results) {
                DeleteError error = result.get();
                deleteErrorNames.add(error.objectName());
            }
        } else {
            //没有桶数据 全部判断失败
            deleteErrorNames.addAll(objectNames);
        }
        return deleteErrorNames;
    }
    /**
     * 生成一个http get请求用的url
     * 可以用这个url进行下载 即使所在的存储桶是私有的 失效时间默认七天 以秒为单位 最长七天
     */
    @SneakyThrows
    public String presignedGetObject(String bucketName,String objectName,Integer expires){
        boolean flag = bucketExists(bucketName);
        String url = "";
        if(flag){
            //没有设置过期时间就按默认的
            if(expires==null){
                minioClient.presignedGetObject(bucketName, objectName);
            }else{
                if(expires<1|| expires>DEFAULT_EXPIRY_TIME){
                    throw new BusinessException(ResMsg.EXPIRES_DATE_ERROR);
                }
                minioClient.presignedGetObject(bucketName, objectName, expires);
            }
        }
        return url;
    }
    /**
     * 生成一个http put请求用的url
     * 浏览器可以用客户端可以用这个url进行上传 即使桶是私有的 失效时间默认七天 以秒为单位 最长七天
     */
    @SneakyThrows
    public String presignedPutObject(String bucketName,String objectName,Integer expires){
        boolean flag = bucketExists(bucketName);
        String url = "";
        if(flag){
            //没有设置过期时间就按默认的
            if(expires==null){
                minioClient.presignedPutObject(bucketName, objectName);
            }else{
                if(expires<1|| expires>DEFAULT_EXPIRY_TIME){
                    throw new BusinessException(ResMsg.EXPIRES_DATE_ERROR);
                }
                minioClient.presignedPutObject(bucketName, objectName, expires);
            }
        }
        return url;
    }
    /**
     * 文件访问路径
     */
    @SneakyThrows
    public String getObjectUrl(String bucketName,String objectName){
        boolean flag = bucketExists(bucketName);
        String url = "";
        if(flag){
            url = minioClient.getObjectUrl(bucketName, objectName);
        }
        return url;
    }

    /**
     * 获取对象的元数据
     */
    @SneakyThrows
    public ObjectStat statObject(String bucketName, String objectName) {
        boolean flag = bucketExists(bucketName);
        if (flag) {
            ObjectStat statObject = minioClient.statObject(bucketName, objectName);
            return statObject;
        }
        return null;
    }
}

创建多用户、多策略

  1. 使用wget命令安装mc命令
wget https://dl.min.io/client/mc/release/linux-amd64/mc -P /usr/local/bin/
  1. 给路径下的mc添加执行权限
chmod +x /usr/local/bin/mc
  1. 绑定Minio服务
mc config host add minio http://127.0.0.1:9000 minioadmin minioadmin --api S3v4
//测试是否绑定Minio服务
mc ls minio
  1. 查看配置信息
mc alias list
  1. 查看minio当前策略的权限
mc admin policy list minio
  1. 自定义策略权限
cd /usr/local/minio/custom_strategy 
touch test.json
vi test.json
//test.json
{
  "Version": "2012-10-17",	// 版本
  "Statement": [
    {
      "Effect": "Allow",		// Allow或者deny，允许或者拒绝下面配置的访问权限
      "Action": [				// 配置权限，上传，删除，下载等等的权限
        "s3:GetBucketLocation", // 授予权限以返回 Amazon S3 存储桶所在的区域 文章底下会详解
		"s3:GetBucketPolicy",   // 授予权限以返回指定存储桶的策略 文章底下会详解
		"s3:ListBucket",		// 查看桶权限
		"s3:GetObject",			// 下载权限
		"s3:PutObject",			// 上传权限
		"s3:DeleteObject"		// 删除权限
      ],
      "Resource": [					// 配置权限的作用范围
        "arn:aws:s3:::test-zl/*","arn:aws:s3:::test-xx/*"	// arn:aws:s3不用动，*表示权限作用于test-zl这个桶下的所有数据，加逗号可以写多个桶
      ]
    }
  ]
}
  1. 给Minio增加自定义策略
mc admin policy add minio test /usr/local/minio/custom_strategy/test.json
//Minio增加策略后检查是否加入
mc admin policy list minio
  1. minio增加用户
mc admin user add minio admintest admintest
//minio查询用户
mc admin user list minio
  1. 给用户增加权限
mc admin policy set minio test user=admintest
wenjian9487
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Minio教程
兴乐安宁的博客
08-20 6473
Minio默认9000端口，在配置文件中加入–address “127.0.0.1:9029” 可更改端口。MINIO_SECRET_KEY：密码，密码不能设置过于简单，不然minio会启动失败，长度最小是8个字符。MINIO_ACCESS_KEY：用户名，长度最小是5个字符。–config-dir：指定集群配置文件目录。集群节点192.168.3.18内容为。集群节点172.16.11.1内容为。修改配置文件后需要重加载配置。...............
搭建minio 集群教程
08-22
搭建minio 集群教程
如何搭建和使用minio？保姆级教程
不积跬步无以至千里，不积小流无以成江河
06-29 3995
如何搭建和使用minio？保姆级教程
Centos7搭建minio分布式集群
10-27
Centos7搭建minio分布式集群
MinIO 入门指南：快速搭建自己的对象存储服务
最新发布
此人有点怪，时发时不发。
04-15 2220
随着数据规模的不断增长，存储和管理数据变得越来越重要。而`MinIO` 是一个优秀的对象存储解决方案，它是一个高性能、轻量级的`对象存储服务器`，兼容 `Amazon S3 API`，本文将带你了解 MinIO 的基本概念、安装方法以及如何使用它搭建自己的对象存储服务。
minio分布式部署搭建文档及安装程序
02-16
1：包含minio分布式部署搭建文档.doxc文档 2：包含minio安装文件
minio使用docker镜像包
12-10
minio使用docker镜像包
linux系统使用minio
03-14
MinIO 是一个高性能的对象存储原生支持 Kubernetes 部署的解决方案。 MinIO 提供了一个 Amazon Web Services S3 兼容 API 并支持所有核心 S3 功能。
三种方式部署单机版Minio，10行命令干就完了~
qq_43511677的博客
09-15 2387
docker-compose一键部署MinIO单机版
分布式minio环境搭建（详细）
m0_74870423的博客
04-13 2283
比如：我们的集群有4个节点，每个节点上一块盘，就算有2两个节点宕机，这个集群仍然是可读的，但是，我们需要3个节点才能让集群写数据。由于是非常轻量级的软件，所以架构上也没有这么复杂，他使用操作系统的文件系统作为存储介质，我们在向任意节点写数据的时候，minIO会自动同步数据到另外的节点，而机制叫做erasure code（纠删码）来保证集群的稳定，保证数据可用，所以我们建议至少使用4个节点来构建集群。早期版本中，每个租户至少有4个盘，最多有16个盘，这个是纠删码的限制，而新版本中是没有限制的。
分布式存储-Minio环境搭建
温暖不了你的心的博客
07-14 4336
MinIO是一个基于Apache License V2.0开源协议的轻量级的对象存储服务。 适合存储大容量非结构化的数据，如图片、视频、日志文件、备份数据和容器/虚拟机镜像等。
【对象存储】MINIO概述与搭建之道
zhzh980的博客
03-02 2310
对象存储是一种基于对象的存储设备，综合了NAS和SAN的优点，同时具有SAN的高速直接访问和NAS的分布式数据共享等优势。适合存储海量图片、视频、日志文件、备份数据、容器镜像等。2006年美国亚马逊发布了AWS S3(Simple Storage Service)服务，正式将对象存储作为一种云存储服务，引入云计算领域，正式开启了对象存储的黄金年代，S3现在也作为一种主流的对象存储协议标准，让很多服务实现厂家都需要进行兼容。
minio基本使用，minio基本使用，minio基本使用
03-24
minio基本使用，minio基本使用，minio基本使用
MinIO环境搭建及使用
诚的博客
06-16 1909
一、什么是MinIO? MinIO是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几kb到最大5T不等。 MinIO是一个非常轻量的服务,可以很简单的和其他应用的结合，类似 NodeJS, Redis 或者 MySQL。 二、MinIO环境搭建 1、Linux系统 方式一、docker安装MinIO（推荐） 使用环境要求：Li
搭建自己本地的minio
qq_30434271的博客
01-18 3253
项目中我们经常需要上传文件，包含图片等一系列资源，除了保存在项目路径下，保存在服务器上现在是十分流行的一种方式，推荐使用minio搭建文件存储系统。论坛更新比较频繁，活跃着多！本文主要是在本地搭建自己的minio，仅供学习使用！ 环境：window10 64位 1，先下载安装包，推荐官方下载地址 minio window 10 64bit 2.进入下载目录，调用cmd窗口，并执行如下命令： .\minio.exe server D:\Photos 简单解释下：在d:\photos目录初始化启动
【Docker】手把手教你在windows使用Docker安装Minio[详细教程]
m0_64210833的博客
06-15 3132
手把手教你在windows使用Docker安装Minio[详细教程]
本地搭建minIO文件存储服务以及springboot整合MinIO提供文件存储服务
m0_45806184的博客
08-05 3432
本地搭建minIO文件存储服务以及springboot整合MinIO提供文件存储服务
Minio搭建
pelosp的博客
05-22 1926
minio搭建和springboot整合
Minio入门系列【1】Windows/Linux/K8S单机部署Minio
热门推荐
吴名氏的博客
09-12 6万+
Minio入门系列【1】Windows/Linux/K8S单机部署Minio
我要使用minio，怎么使用
07-09
MinIO是一个开源的对象存储服务器，它兼容Amazon S3 API，可以在本地或私有云环境中搭建自己的对象存储服务。以下是使用MinIO的一般步骤： 1. 下载和安装MinIO：你可以从MinIO的官方网站（https://min.io/）下载...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值