如何使用Minio进行对象存储和数据管理

Posted 2023-03-16

Minio是一个开源的对象存储服务器，可用于存储和管理各种类型的数据，包括图像、视频、文档等等。本文将介绍如何安装和配置Minio，使用Minio进行对象存储，以及如何利用Minio的高级功能和解决常见问题。

一、简介

1.1 什么是Minio？

Minio是一个开源的对象存储服务器，旨在为云应用程序和基于容器的环境提供高性能、可扩展的存储解决方案。Minio支持Amazon S3 API，因此可以轻松地与现有的S3应用程序集成，并且可用于存储和管理各种类型的数据，包括图像、视频、文档等等。Minio还提供了一些高级功能，如分布式模式、负载均衡和安全加密，以及一个强大的命令行工具集Minio客户端（mc），可帮助您更好地管理和控制您的数据。

1.2 为什么使用Minio？

1. 可扩展性：Minio具有良好的可扩展性，可在需要时添加更多的存储容量和节点。
2. 低成本：Minio是开源的，因此不需要额外的许可证费用。
3. 高性能：Minio在处理大型文件时表现出色，并且具有快速的读写速度。
4. 高度可靠：Minio提供了多个数据复制选项，以确保数据的可靠性和容错性。
5. 安全性：Minio支持访问控制和加密，以保护您的数据免受未经授权的访问。

二、安装和配置

2.1 下载和安装Minio

下载和安装Minio非常简单，您只需按照以下步骤操作即可：

1. 访问Minio的官方网站 ​​https://min.io/downloads​​ ，选择适合您操作系统的版本，并下载最新版本的Minio二进制文件。
2. 解压下载的文件，您将得到一个可执行文件minio（在Windows上为minio.exe）和一个可执行文件minioctl（在Windows上为minioctl.exe）。
3. 将Minio二进制文件移动到您想要安装的目录。
4. 在终端或命令提示符下运行以下命令来启动Minio：

./minio server /path/to/data

其中，​​/path/to/data​​是您希望将数据存储的目录。

5. 您可以在浏览器中访问http://localhost:9000来访问Minio Web UI。
6. 进入Minio Web UI后，您可以使用您的AWS S3 API密钥来进行身份验证。

下面是windows上启动步骤：

到此，Minio已成功安装并运行。

2.2 配置Minio

1. 配置访问密钥和密钥ID：Minio使用AWS S3 API，因此您需要提供访问密钥和密钥ID来进行身份验证。可以在启动Minio时通过环境变量设置这些值，也可以通过命令行选项或配置文件进行设置。
2. 配置端口和绑定地址：默认情况下，Minio使用9000端口进行通信。您可以在启动Minio时指定一个不同的端口号。如果您希望Minio仅绑定到特定的IP地址，则可以使用​​--address​​选项指定。
3. 配置存储后端：Minio可以使用本地磁盘或远程云存储作为存储后端。如果您想使用云存储，则需要提供相应的凭据和API密钥。可以在启动Minio时通过命令行选项或配置文件进行设置。
4. 配置加密和访问控制：Minio支持对数据进行加密和访问控制。可以通过命令行选项或配置文件进行设置，以指定加密密钥、启用或禁用访问控制等。
5. 配置高级选项：Minio还提供了许多高级选项，如分布式模式、负载均衡、性能调优等。可以在Minio的官方文档中找到更多详细信息。

更详细的配置信息可以参考官方文档：​​https://min.io/docs/minio/linux/index.html​​

三、对象存储

3.1 对象存储是什么？

对象存储是一种用于存储和管理非结构化数据的数据存储模式。与传统的文件系统不同，对象存储是基于对象的，每个对象都有唯一的标识符和元数据，可以存储各种不同类型的数据，如文本、图像、视频、音频等。

对象存储系统通常是分布式的，数据被分散存储在多个物理设备上，这种分散存储提供了高可用性和可扩展性。对象存储还提供了许多高级功能，如数据复制、数据迁移、数据版本控制、数据备份和数据恢复等。

对象存储已成为云计算基础设施的核心组件之一，广泛应用于云存储、备份和归档、大数据分析、物联网等领域。

3.2 创建和管理桶（Bucket）

在 MinIO 中，桶（Bucket）是存储对象的基本单位。在创建对象之前，您需要先创建一个桶，然后将对象存储到桶中。以下是在 MinIO 中创建和管理桶的步骤：

1. 启动 MinIO 服务器：您可以在本地或云上启动 MinIO 服务器。在本地，您可以使用 MinIO 客户端或 Docker 容器启动 MinIO 服务器。在云上，您可以使用 MinIO 的托管服务或在虚拟机上部署 MinIO 服务器。
2. 登录 MinIO Web 界面：打开浏览器，输入 MinIO 服务器的 IP 地址和端口号（默认是9000），然后输入您的访问密钥和秘密密钥，登录 MinIO Web 界面。
3. 创建桶：在 MinIO Web 界面的左侧导航栏中，单击“新建桶”按钮，然后输入桶的名称和存储区域，单击“创建”按钮即可创建桶。您还可以使用 MinIO 客户端或 S3 API 创建桶。

4. 管理桶：在 MinIO Web 界面中，您可以单击桶的名称进入桶的管理页面。在桶的管理页面中，您可以上传和下载对象，删除对象，设置桶的访问权限等等。您还可以使用 MinIO 客户端或 S3 API 进行桶的管理。

总之，在 MinIO 中创建和管理桶非常简单，只需要几个步骤即可完成。桶是 MinIO 存储对象的基本单位，可以按照您的需求创建多个桶，并在桶中存储和管理对象。

3.3 上传和下载文件

1. 登录 MinIO Web 界面：打开浏览器，输入 MinIO 服务器的 IP 地址和端口号（默认是9000），然后输入您的访问密钥和秘密密钥，登录 MinIO Web 界面。
2. 创建桶：在 MinIO Web 界面的左侧导航栏中，单击“新建桶”按钮，然后输入桶的名称和存储区域，单击“创建”按钮即可创建桶。
3. 上传文件：在 MinIO Web 界面中，单击桶的名称进入桶的管理页面。在桶的管理页面中，单击“上传文件”按钮，选择要上传的文件，然后单击“上传”按钮即可将文件上传到桶中。您还可以使用 MinIO 客户端或 S3 API 进行文件的上传。
4. 下载文件：在 MinIO Web 界面中，单击桶的名称进入桶的管理页面。在桶的管理页面中，找到要下载的文件，单击文件名，然后单击“下载”按钮即可将文件下载到本地计算机。您还可以使用 MinIO 客户端或 S3 API 进行文件的下载。

四、安全

4.1 访问控制列表（ACL）

1. 设置桶的 ACL：在 MinIO Web 界面中，单击桶的名称进入桶的管理页面。在桶的管理页面中，单击“权限”选项卡，选择要设置的 ACL，单击“保存”按钮即可设置桶的 ACL。您还可以使用 MinIO 客户端或 S3 API 进行桶的 ACL 设置。
2. 设置对象的 ACL：在 MinIO Web 界面中，找到要设置 ACL 的对象，单击对象的名称进入对象的管理页面。在对象的管理页面中，单击“权限”选项卡，选择要设置的 ACL，单击“保存”按钮即可设置对象的 ACL。您还可以使用 MinIO 客户端或 S3 API 进行对象的 ACL 设置。
3. 验证 ACL：在 MinIO Web 界面中，单击桶或对象的名称进入相应的管理页面，然后单击“权限”选项卡，查看当前 ACL 的设置。

ACL 可以帮助您控制桶和对象的访问权限，保护您的数据不被未经授权的用户访问。

4.2 加密

在 MinIO 中，您可以使用服务器端加密（SSE）来保护数据的安全性。SSE 是一种在服务器端加密数据的技术，它可以在数据上传到服务器之前对数据进行加密，并在下载数据时对其进行解密。MinIO 支持两种 SSE 加密方式：SSE-S3 和 SSE-C。

SSE-S3 是 Amazon S3 服务器端加密的一种实现方式，它使用服务器管理的加密密钥来加密数据。在 MinIO 中，您可以使用 SSE-S3 对桶和对象进行加密。要使用 SSE-S3，您需要创建一个 Amazon S3 兼容的加密密钥，然后将其配置到 MinIO 服务器上。

SSE-C 是一种客户端管理的加密方式，它允许客户端使用自己的加密密钥来加密数据。在 MinIO 中，您可以使用 SSE-C 对对象进行加密。要使用 SSE-C，您需要提供加密密钥和加密算法的相关信息。

以下是在 MinIO 中使用 SSE 加密的步骤：

1. 创建加密密钥：如果要使用 SSE-S3 进行加密，您需要创建一个 Amazon S3 兼容的加密密钥。如果要使用 SSE-C 进行加密，您需要提供加密密钥和加密算法的相关信息。
2. 配置加密密钥：在 MinIO Web 界面中，单击桶或对象的名称进入相应的管理页面，然后单击“设置”选项卡，找到“SSE 加密”选项，选择要使用的 SSE 加密方式，然后输入加密密钥和加密算法的相关信息。
3. 上传或下载加密文件：在 MinIO Web 界面中，您可以上传或下载加密文件。上传时，MinIO 会对文件进行加密，下载时，MinIO 会对文件进行解密。

五、Minio客户端（mc）

Minio客户端是一款基于命令行界面的客户端工具，用于与Minio对象存储服务器进行交互。Minio客户端提供了一个简单、易用的接口，使得用户可以通过命令行快速、方便地上传、下载、管理对象存储数据。

使用Minio客户端，您可以执行以下任务：

• 列出所有的桶(bucket)
• 创建、删除桶(bucket)
• 上传、下载对象(object)
• 复制、移动对象
• 管理对象的权限、元数据等属性

Minio客户端支持多种操作系统，包括Windows、Linux、macOS等。您可以在Minio的官方网站上下载相应版本的Minio客户端，并根据需要进行安装和配置。

以下是一些Minio客户端的基本命令：

• ​​mc ls​​: 列出所有的桶(bucket)
• ​​mc mb [options] <bucket>​​: 创建一个新的桶(bucket)
• ​​mc rm [options] <object>​​: 删除一个对象(object)
• ​​mc cp [options] <source> <target>​​: 复制一个对象(object)到目标位置
• ​​mc mirror [options] <source> <target>​​: 复制源位置的所有对象到目标位置
• ​​mc policy [options] <bucket>​​: 获取或设置桶的访问策略(policy)

docker搭建minio以及java sdk使用

docker搭建minio以及java使用

1minio简洁

MinIO 是一款高性能、分布式的对象存储系统. 它是一款软件产品, 可以100%的运行在标准硬件。即X86等低成本机器也能够很好的运行MinIO。

MinIO与传统的存储和其他的对象存储不同的是：它一开始就针对性能要求更高的私有云标准进行软件架构设计。因为MinIO一开始就只为对象存储而设计。所以他采用了更易用的方式进行设计，它能实现对象存储所需要的全部功能，在性能上也更加强劲，它不会为了更多的业务功能而妥协，失去MinIO的易用性、高效性。 这样的结果所带来的好处是：它能够更简单的实现局有弹性伸缩能力的原生对象存储服务。

MinIO在传统对象存储用例（例如辅助存储，灾难恢复和归档）方面表现出色。同时，它在机器学习、大数据、私有云、混合云等方面的存储技术上也独树一帜。当然，也不排除数据分析、高性能应用负载、原生云的支持。

minio社区版本开源免费，在没有预算使用oss的时候可以考虑使用。

2 docker搭建minio

minio是支持云原生的，所以直接讲使用docker来搭建，当然也可以使用k8s，直接下载官方的chart使用即可。

2.1 单节点

单节点可以直接使用docker run启动即可

docker run \\
  -p 9000:9000 \\
  -p 9001:9001 \\
  minio/minio server /data --console-address ":9001"

也可以使用docker-compose来运行。

编写docker-compose.yaml

version: '3'
services:
  minio:
    image: minio/minio
    hostname: "minio"
    ports:
      - 9000:9000 
      - 9001:9001
    environment:
      MINIO_ACCESS_KEY: admin #控制台登录账号
      MINIO_SECRET_KEY: 12345678 #控制台登录密码
    volumes:
      - ./data:/data      #存储路径         
      - ./config:/root/.minio/   #配置文件  
    command: server --console-address ':9001' /data  
    privileged: true
    restart: always

创建挂载的文件目录，运行docker-compos启动。

docker-compser up -d

输入ip:9001 输入admin/12345678进入控制台

控制台：

创建bucket，就可以上传文件了。

输入名称保存。

可以配置，相关策略，这里就不说明了。

可以上传下载操对象文件。

2.2 多节点部署

多节点部署使用docker-compse来模拟。创建4个节点，每个节点挂载两份数据。

编写docker-compose.yaml

version: '3'

# starts 4 docker containers running minio server instances.
# using nginx reverse proxy, load balancing, you can access
# it through port 9000.
services:
  minio1:
    image: minio/minio
    hostname: minio1
    volumes:
      - ./data1-1:/data1
      - ./data1-2:/data2
    expose:
      - "9000"
      - "9001"
    environment:
      MINIO_ROOT_USER: minio
      MINIO_ROOT_PASSWORD: minio123
    command: server --console-address ":9001" http://minio{1...4}/data{1...2}
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      interval: 30s
      timeout: 20s
      retries: 3

  minio2:
    image: minio/minio
    hostname: minio2
    volumes:
      - ./data2-1:/data1
      - ./data2-2:/data2
    expose:
      - "9000"
      - "9001"
    environment:
      MINIO_ROOT_USER: minio
      MINIO_ROOT_PASSWORD: minio123
    command: server --console-address ":9001" http://minio{1...4}/data{1...2}
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      interval: 30s
      timeout: 20s
      retries: 3

  minio3:
    image: minio/minio
    hostname: minio3
    volumes:
      - ./data3-1:/data1
      - ./data3-2:/data2
    expose:
      - "9000"
      - "9001"
    environment:
      MINIO_ROOT_USER: minio
      MINIO_ROOT_PASSWORD: minio123
    command: server --console-address ":9001" http://minio{1...4}/data{1...2}
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      interval: 30s
      timeout: 20s
      retries: 3

  minio4:
    image: minio/minio
    hostname: minio4
    volumes:
      - ./data4-1:/data1
      - ./data4-2:/data2
    expose:
      - "9000"
      - "9001"
    environment:
      MINIO_ROOT_USER: minio
      MINIO_ROOT_PASSWORD: minio123
    command: server --console-address ":9001" http://minio{1...4}/data{1...2}
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      interval: 30s
      timeout: 20s
      retries: 3

  nginx:
    image: nginx:1.19.2-alpine
    hostname: nginx
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
    ports:
      - "9000:9000"
      - "9001:9001"
    depends_on:
      - minio1
      - minio2
      - minio3
      - minio4

创建挂载的对应的data目录和nginx目录。

使用nginx负载均衡4个节点，创建nginx.conf。

user  nginx;
worker_processes  auto;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;

events {
    worker_connections  4096;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;
    sendfile        on;
    keepalive_timeout  65;

    # include /etc/nginx/conf.d/*.conf;

    upstream minio {
        server minio1:9000;
        server minio2:9000;
        server minio3:9000;
        server minio4:9000;
    }

    upstream console {
        ip_hash;
        server minio1:9001;
        server minio2:9001;
        server minio3:9001;
        server minio4:9001;
    }

    server {
        listen       9000;
        listen  [::]:9000;
        server_name  localhost;

        # To allow special characters in headers
        ignore_invalid_headers off;
        # Allow any size file to be uploaded.
        # Set to a value such as 1000m; to restrict file size to a specific value
        client_max_body_size 0;
        # To disable buffering
        proxy_buffering off;

        location / {
            proxy_set_header Host $http_host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;

            proxy_connect_timeout 300;
            # Default is HTTP/1, keepalive is only enabled in HTTP/1.1
            proxy_http_version 1.1;
            proxy_set_header Connection "";
            chunked_transfer_encoding off;

            proxy_pass http://minio;
        }
    }

    server {
        listen       9001;
        listen  [::]:9001;
        server_name  localhost;

        # To allow special characters in headers
        ignore_invalid_headers off;
        # Allow any size file to be uploaded.
        # Set to a value such as 1000m; to restrict file size to a specific value
        client_max_body_size 0;
        # To disable buffering
        proxy_buffering off;

        location / {
            proxy_set_header Host $http_host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
            proxy_set_header X-NginX-Proxy true;

            # This is necessary to pass the correct IP to be hashed
            real_ip_header X-Real-IP;

            proxy_connect_timeout 300;
            
            # To support websocket
            proxy_http_version 1.1;
            proxy_set_header Upgrade $http_upgrade;
            proxy_set_header Connection "upgrade";
            
            chunked_transfer_encoding off;

            proxy_pass http://console;
        }
    }
}

运行。

docker-compser up -d

然后进入控制台，操作和单节点一样。

3 java sdk使用minio

sdk使用minio要先获取AccessKey和SecretKey。

在控制台生成。

项目pom文件引入。

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

编写上传、下载、删除的接口。

package com.test.minio;

import javax.servlet.http.HttpServletResponse;
import java.io.InputStream;

/**
 * 存储文件
 *
 * @author jiangyulu
 */
public interface FileService {
    /**
     * 上传文件
     *
     * @param inputStream inputStream
     * @param fdsFileName    fdsFileName
     * @param img         img
     * @return UUID
     */
    String upload(InputStream inputStream, String fdsFileName, boolean img);


    /**
     * 下载文件
     *
     * @param fdsFileName 文件在fds中的名称
     * @param fileName    重新指定的文件名
     * @param response    response
     */
    void download(String fdsFileName, String fileName, HttpServletResponse response);

    /**
     * 删除
     *
     * @param fdsFileName fdsFileName
     */
    void delete(String fdsFileName);
}

写实现类。

package com.test.minio.impl;


import com.test.minio.FileService;
import io.minio.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.IOUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.net.URLEncoder;
import java.util.UUID;


/**
 * @author jaingyulu
 */
@Slf4j
@Service("minio")
public class MinioFileServiceImpl implements FileService {

    @Value("{$minio.endpoint}")
    private String endpoint;

    @Value("{$minio.accessKeyId}")
    private String accessKeyId;

    @Value("{$minio.accessKeySecret}")
    private String accessKeySecret;

    @Value("{$minio.bucketName}")
    private String bucketName;


    @Override
    public String upload(InputStream inputStream, String fdsFileName, boolean img) {

        try {
            MinioClient minioClient =
                    MinioClient.builder()
                            .endpoint(endpoint)
                            .credentials(accessKeyId, accessKeySecret)
                            .build();

            boolean found =
                    minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
            if (found) {
                log.info("Bucket already exists.");
            } else {
                minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
            }

            if (!img) {
                minioClient.putObject(
                        PutObjectArgs.builder()
                                .bucket(bucketName)
                                .object(fdsFileName)
                                .stream(inputStream, inputStream.available(), -1)
                                .build());
            } else {
                minioClient.putObject(
                        PutObjectArgs.builder()
                                .bucket(bucketName)
                                .object(fdsFileName)
                                .stream(inputStream, inputStream.available(), -1)
                                .contentType("image/png")
                                .build());
            }

            inputStream.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return UUID.randomUUID().toString();
    }

    @Override
    public void download(String fdsFileName, String fileName, HttpServletResponse response) {
        InputStream in = null;
        try {
            MinioClient minioClient =
                    MinioClient.builder()
                            .endpoint(endpoint)
                            .credentials(accessKeyId, accessKeySecret)
                            .build();
            StatObjectResponse objectStat = minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(fdsFileName).build());
            response.setContentType(objectStat.contentType());
            //response.setContentType(MediaType.APPLICATION_OCTET_STREAM_VALUE);
            response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8"));
            in = minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(fdsFileName).build());
            IOUtils.copy(in, response.getOutputStream());
        } catch (Exception e) {
            log.error(e.getMessage());
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    log.error(e.getMessage());
                }
            }
        }
    }

    @Override
    public void delete(String fdsFileName) {
        try {
            MinioClient minioClient =
                    MinioClient.builder()
                            .endpoint(endpoint)
                            .credentials(accessKeyId, accessKeySecret)
                            .build();
            minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(fdsFileName).build());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

以上完成了minio文件操作的基本功能，其他功能可以查看官方的文档。8.3.0版本sdk比起7.x的变化还是比较大的。