Linux部署minio的详细步骤

Table of Contents

Linux部署minio详细步骤

最近项目上需要用到文件上传和文件下载，想到之前项目用到了minio，于是决定使用它作为我们的文件服务器，为什么选用minio呢，主要的优点就是我之前用过，对于单体小项目非常的方便、轻量级，写一个工具类即可完成文件上传下载。
下面我主要会介绍三个部分： minio在Linux环境下的单体服务部署→SpringBoot集成Mino→基于Minio的文件上传下载工具类。

minio在Linux环境下的单体服务部署

使用的操作系统是 CentOS Linux 7 (Core)

下载Minio的二进制文件，可以使用命令下载，也可以手动下载后上传到服务器。下载地址：

wget https://dl.min.io/server/minio/release/linux-amd64/minio

我这里是手动下载Minio的二进制文件后上传到服务器的/usr/local/bin路径下面

文件上传好后记得授予权限。

chmod-X minio

启动前需要把基本数据目录、用户配置目录进行创建。

数据目录：

mkdir-p /data/minio

用户配置目录：

mkdir-p /etc/minio

创建完基础目录后需要编写minio的 systemd 启动服务配置

首先通过vi命令直接在下面路径创建并且编辑服务配置文件：

vi /etc/systemd/system/minio.service

进入minio.service配置文件后，按insert键把下面的配置进行赋值数据插入：

[Unit]Description=MinIO
Documentation=https://docs.min.io
Wants=network-online.target
After=network-online.target
[Service]User=root
Group=root
ExecStart=/usr/local/bin/minio server /data --console-address ":9001"Restart=always
LimitNOFILE=65536EnvironmentFile=-/etc/default/minio
[Install]WantedBy=multi-user.target

配置插入好后，点击esc，输入:wq进行退出保存，到本步基本已经完成了基础配置，是不是很简单。

设置开机自启，查看启动状态

开机自启动

sudo systemctl daemon-reload
sudo systemctl enable minio

启动服务

sudo systemctl start minio

查看启动状态

sudo systemctl status minio

当我们看到如下状态即为部署成功：

SpringBoot集成minio

服务部署成功后我们进行代码环境的集成，以SpringBoot为例，这个集成也是比较方便的，简单两步即可配置成功。

pom文件配置

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

2.application.yml文件配置

minio:
url: http://127.0.0.1:9000 #ip地址
accessKey: minioadmin #
默认账号
secretKey: minioadmin #
默认密码
secure: false#如果是true，则用的是https而不是http,默认值是true
bucketName: "jyj"
# 桶的名字 相当于文件夹

minio工具类

类似工具类网上也比较多，下面我就贴出一个仅供大家参考，目的是为了大家能够快速使用上手：

import io.minio.*;
import io.minio.http.Method;
import io.minio.messages.Bucket;
import io.minio.messages.Item;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.util.FastByteArrayOutputStream;
import org.springframework.util.StringUtils;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.UUID;
@Slf4j
@Component
public class MinIOUtil {
    @Resource
    private MinioConfig minioConfig;
    @Resource
    private MinioClient minioClient;
    /**
     * 查看存储bucket是否存在
     *
     * @param bucketName 存储桶名称
     * @return boolean
     */
    public Boolean bucketExists(String bucketName) {
        Boolean found;
        try {
            found = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return found;
    }
    /**
     * 创建存储bucket
     *
     * @param bucketName 存储桶名称
     * @return Boolean
     */
    public Boolean makeBucket(String bucketName) {
        try {
            minioClient.makeBucket(MakeBucketArgs.builder()
                    .bucket(bucketName)
                    .build());
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }
    /**
     * 删除存储bucket
     *
     * @param bucketName 存储桶名称
     * @return Boolean
     */
    public Boolean removeBucket(String bucketName) {
        try {
            minioClient.removeBucket(RemoveBucketArgs.builder()
                    .bucket(bucketName)
                    .build());
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }
    /**
     * 获取全部bucket
     *
     * @return 存储桶列表
     */
    public List<Bucket> getAllBuckets() {
        try {
            return minioClient.listBuckets();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 文件上传
     *
     * @param file 文件
     * @return 文件对象名称
     */
    public String upload(MultipartFile file) {
        String originalFilename = file.getOriginalFilename();
        System.out.println(originalFilename);
        if (!StringUtils.hasText(originalFilename)) {
            throw new RuntimeException();
        }
        String fileName = UUID.randomUUID() + originalFilename.substring(originalFilename.lastIndexOf("."));
        String prefix = new SimpleDateFormat("yyyy/MM/dd").format(new Date());
        String objectName = prefix + "/" + fileName;
        try {
            PutObjectArgs objectArgs = PutObjectArgs.builder().bucket(minioConfig.getBucketName()).object(objectName)
                    .stream(file.getInputStream(), file.getSize(), -1).contentType(file.getContentType()).build();
            // 文件名称相同会覆盖
            minioClient.putObject(objectArgs);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
        return objectName;
    }
    /**
     * 预览图片
     *
     * @param fileName 文件名称
     * @return 文件预览链接
     */
    public String preview(String fileName) {
        // 查看文件地址
        GetPresignedObjectUrlArgs build = GetPresignedObjectUrlArgs
                .builder()
                .bucket(minioConfig.getBucketName())
                .object(fileName).method(Method.GET).build();
        try {
            String url = minioClient.getPresignedObjectUrl(build);
            return url;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 文件下载
     *
     * @param fileName 文件名称
     * @param res      response
     */
    public void download(String fileName, HttpServletResponse res) {
        GetObjectArgs objectArgs = GetObjectArgs.builder().bucket(minioConfig.getBucketName())
                .object(fileName).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.addHeader("Content-Disposition", "attachment;fileName=" + fileName);
                try (ServletOutputStream stream = res.getOutputStream()) {
                    stream.write(bytes);
                    stream.flush();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 查看文件对象
     *
     * @return 存储bucket内文件对象信息
     */
    public List<Item> listObjects() {
        Iterable<Result<Item>> results = minioClient.listObjects(
                ListObjectsArgs.builder().bucket(minioConfig.getBucketName()).build());
        List<Item> items = new ArrayList<>();
        try {
            for (Result<Item> result : results) {
                items.add(result.get());
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
        return items;
    }
    /**
     * 删除
     *
     * @param fileName 文件名称
     * @return 是否删除成功
     */
    public boolean remove(String fileName) {
        try {
            minioClient.removeObject(RemoveObjectArgs.builder()
                    .bucket(minioConfig.getBucketName())
                    .object(fileName)
                    .build());
        } catch (Exception e) {
            return false;
        }
        return true;
    }
}

到这里分享就结束了，希望大家能有收获！

以上就是Linux部署minio详细步骤的详细内容，更多相关资料请阅读主机测评网其它文章！

原创文章，作者：admin，如若转载，请注明出处：https://hostingchat.cn/3087.html