minio开源的对象存储服务器安装及使用-Toy模板网

这篇具有很好参考价值的文章主要介绍了minio开源的对象存储服务器安装及使用。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

1.minio的介绍

MinIO是一个开源的对象存储服务器，设计用于实现高性能、可扩展的云存储。它兼容Amazon S3云存储服务的API，因此可以与现有的S3兼容应用程序进行集成。
MinIO可以部署在本地服务器、私有云环境或公共云上，如AWS、Azure、Google Cloud等。它通过将数据分散在多个独立节点上实现高可用性和容错性，同时提供强大的分布式对象存储能力。
使用MinIO，你可以通过简单的RESTful API/API对象将数据上传、存储和检索到MinIO服务器。MinIO还提供了许多功能，如数据加密、存储桶生命周期管理、事件通知、访问控制等，以满足各种存储需求。
由于MinIO的可扩展性和高性能，它被广泛用于构建各种应用程序，如数据湖、备份和恢复、文档存储、图像和视频存储等。它还是云原生生态系统中的一部分，可以与Kubernetes、Docker等常用工具无缝集成。
总而言之，MinIO是一个快速、可扩展和开源的对象存储服务器，为开发人员和组织提供了灵活、可靠的数据存储解决方案

2.安装docker版minio

1.拉取docker镜像

sudo docker pull minio/minio

minio 安装,中间件,java,开源,服务器

2.创建映射文件

mkdir -p /docker/app/minio/data
mkdir -p /docker/app/minio/config

3.启动

docker run -p 9000:9000 -p 9090:9090 --name minio -d --restart=always -e "MINIO_ACCESS_KEY=minioadmin"  -e "MINIO_SECRET_KEY=minioadmin" -v /docker/app/minio/data:/data -v /docker/app/minio/config:/root/.minio minio/minio server /data --console-address ":9090" -address ":9000"

这个命令是用来在 Docker 中运行 MinIO 容器的。下面是各个参数的说明：
● -p 9000:9000 -p 9090:9090 ：将容器的 9000 端口映射到主机的 9000 端口，将容器的 9090 端口映射到主机的 9090 端口。
● --name minio：给容器取一个名称为 “minio”。
● -d：以后台模式运行容器。
● --restart=always：当容器退出时，总是重启容器。
● -e "MINIO_ACCESS_KEY=minioadmin" -e "MINIO_SECRET_KEY=minioadmin"：设置环境变量，指定 MinIO 的访问密钥和密钥。
● -v /docker/app/minio/data:/data：将主机上 /docker/app/minio/data 目录挂载到容器的 /data 目录，用于持久化存储 MinIO 数据。
● -v /docker/app/minio/config:/root/.minio：将主机上 /docker/app/minio/config 目录挂载到容器的 /root/.minio 目录，用于持久化存储 MinIO 配置文件。
● minio/minio：使用 MinIO 官方提供的镜像。
● server /data：运行容器时执行的命令，启动 MinIO 服务器并指定数据目录为 /data。
● --console-address ":9090"：设置 MinIO 控制台的地址为 :9090，即容器的 9090 端口。
● -address ":9000"：设置 MinIO 服务器的监听地址为 :9000，即容器的 9000 端口。

PS:这个命令会创建一个名为 “minio” 的容器，该容器运行 MinIO 对象存储服务器，并将数据存储在本地的指定目录中。你可以使用 http://localhost:9000 访问 MinIO 服务器，并使用指定的访问密钥和密钥进行身份验证。另外，你也可以使用 http://localhost:9090 访问 MinIO 控制台进行管理操作。

4.验证

minio 安装,中间件,java,开源,服务器

3.开发中使用minio

maven依赖

    <!--引入MINIO依赖-->
        <dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <version>8.3.0</version>
        </dependency>
        <dependency>
            <groupId>me.tongfei</groupId>
            <artifactId>progressbar</artifactId>
            <version>0.5.3</version>
        </dependency>
        <dependency>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>okhttp</artifactId>
            <version>4.8.1</version>
        </dependency>

1.工具类准备

minio核心配置类

/**
 * minio核心配置类
 * 通过注入 MinIO 服务器的相关配置信息，得到 MinioClient 对象，我们上传文件依赖此对象
 */
@Configuration
public class MinioConfig {

    @Autowired
    private MinioProperties prop;

    /**
     * 获取 MinioClient
     *
     * @return MinioClient
     */
    @Bean
    public MinioClient minioClient() {
        return MinioClient.builder().endpoint(prop.getEndpoint()).credentials(prop.getAccessKey(), prop.getSecretKwy())
            .build();
    }
}

minio配置类:

/**
 * minio 属性值
 */
@Data
@Component
@ConfigurationProperties(prefix = "minio")
public class MinioProperties {
    /** 连接url */
    private String endpoint;
    /** 公钥 */
    private String accessKey;
    /** 私钥 */
    private String secretKwy;
    /** 桶名 */
    private String bucketName;
}

minio工具类

@Component
public class MinioUtils {
    @Autowired
    private MinioClient minioClient;
    @Autowired
    private MinioProperties minioProperties;

    /**
     * 创建桶
     *
     * @param bucketName 桶名称
     */
    @SneakyThrows
    public void createBucket(String bucketName) {
        boolean found = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
        if (!found) {
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).region("cn-beijing").build());
        }
    }

    /**
     * 删除桶
     *
     * @param bucketName 桶名称
     */
    @SneakyThrows
    public void removeBucket(String bucketName) {
        minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
    }

    /**
     * 上传文件
     *
     * @param fileName 文件名
     * @param stream 流
     * @param fileSize 文件大小
     * @param type 文件类型
     * @throws Exception
     */
    public void uploadFile(String bucketName, String fileName, InputStream stream, Long fileSize, String type)
    throws Exception {
        minioClient.putObject(PutObjectArgs.builder().bucket(bucketName).object(fileName).stream(stream, fileSize, -1)
            .contentType(type).build());
    }

    /**
     * 判断文件夹是否存在
     *
     * @param bucketName 桶名称
     * @param prefix 文件夹名字
     * @return
     */
    @SneakyThrows
    public Boolean folderExists(String bucketName, String prefix) {
        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 路径
     */
    @SneakyThrows
    public void createFolder(String bucketName, String path) {
        minioClient.putObject(PutObjectArgs.builder().bucket(bucketName).object(path)
            .stream(new ByteArrayInputStream(new byte[] {}), 0, -1).build());
    }

    /**
     * 获取文件在minio在服务器上的外链
     *
     * @param bucketName 桶名称
     * @param objectName 文件名
     * @return 可访问的URL
     * expiry(int duration, TimeUnit unit) 设置有效时间,这里是设置为URL的有效期为1天,即在一天以后国企.
     */
    @SneakyThrows
    public String getObjectUrl(String bucketName, String objectName) {
        return minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder().method(Method.GET).bucket(
            bucketName).object(objectName).expiry(1, TimeUnit.DAYS).build());
    }

    /**
     * 生成可访问的url
     *
     * @param filePath 文件路径
     * @return 可访问的文件, 过期时间1day
     * @author HuangLongFei
     * @since 2023/3/11
     */
    public String generateUrl(String filePath) {
        return getObjectUrl(minioProperties.getBucketName(), filePath);
    }

    /**
     * 批量删除文件
     *
     * @param filePathList 文件路径列表
     * @author HuangLongFei
     * @since 2023/7/17
     */
    public void deleteFile(List<String> filePathList) {
        if (CollectionUtils.isEmpty(filePathList)) {
            return;
        }
        // 构建要删除的文件列表
        List<DeleteObject> deleteFileList = new ArrayList<>();
        for (String filePath : filePathList) {
            deleteFileList.add(new DeleteObject(filePath));
        }
        try {
            // 批量删除文件
            RemoveObjectsArgs fileArgs = RemoveObjectsArgs.builder().bucket(minioProperties.getBucketName()).objects(
                deleteFileList).build();
            Iterable<Result<DeleteError>> fileDeleteResult = minioClient.removeObjects(fileArgs);
            // 注意这里必须迭代返回结果,因为removeObjects是惰性的
            for (Result<DeleteError> result : fileDeleteResult) {
                DeleteError deleteError = result.get();
            }
        } catch (Exception e) {
            throw new ProjectException(ExceptionEnum.MINIO_CALL_ERROR);
        }
    }
}

    /**
     * 获取minio中,某个bucket中所有的文件名
     */
    public List<String> getFileList(String bucketName) {
        // 根据bucketName,获取该桶下所有的文件信息
        Iterable<Result<Item>> results = minioClient.listObjects(ListObjectsArgs.builder().bucket(bucketName)
            .recursive(true).build());
        List<String> fileNameList = new ArrayList<>();
        for (Result<Item> result : results) {
            Item item;
            String fileName = null;
            try {
                item = result.get();
                fileName = item.objectName();
                fileNameList.add(fileName);
            } catch (Exception e) {
                log.error("call the minioClient.listObjects Error. result={} and message = {}", result, e);
            }
            // 获取文件的访问路径
            if (StringUtils.isNotBlank(fileName)) {
                String accessUrl = getObjectUrl(bucketName, fileName);
            }
        }
        return fileNameList;
    }

application.yml文件

## 配置minio的公钥和私钥
minio:
  bucket-name: 
  endpoint: 
  access-key: 
  secret-kwy:

2.测试

@SpringBootTest
public class minioTest {
    @Autowired
    private MinioUtils minioUtils;
    @Autowired
    private MinioProperties minioProperties;
    private final static String BUCKET_NAME_TEST = "bucket-test";

    /***
     * 测试目的:创建一个bucket
     */
    @Test
    public void createBucket() {
        String bucketName = BUCKET_NAME_TEST;
        minioUtils.createBucket(bucketName);
        System.out.println("create " + bucketName + " success!");
    }

    /***
     * 测试目的:删除一个bucket
     */
    @Test
    public void removeBucket() {
        String bucketName = BUCKET_NAME_TEST;
        minioUtils.removeBucket(bucketName);
        System.out.println("remove " + bucketName + " success!");
    }

    /***
     * 测试目的:创建文件夹,并上传路径
     */
    @Test
    public void uploadFile() {
        String filePath = "E:/tempoary/2023-07-21_10-53-35.png";
        File file = new File(filePath);
        // 设置要上传的路径,例如 /test/2023/123.jpg
        filePath = "/test/2023/" + file.getName();
        try {
            FileInputStream fileInputStream = new FileInputStream(file);
            minioUtils.uploadFile(BUCKET_NAME_TEST, filePath, fileInputStream, file.length(), "image/jpeg");
            System.out.println("上传成功!,文件路径:" + filePath);
        } catch (Exception e) {
            System.out.println("上传失败");
            e.printStackTrace();
        }
    }

    /***
     * 测试目的:生成可访问的图片的URL
     */
    @Test
    public void getObjectUrl() {
        String filePath = "test/2023/2023-07-21_10-53-35.png";
        String url = minioUtils.getObjectUrl(BUCKET_NAME_TEST, filePath);
        System.out.println(url);
    }
}