Docker 搭建 Minio 容器 (完整详细版)

已于 2023-12-01 21:45:04 修改
阅读量1.3w 收藏 114
点赞数 40
分类专栏： Docker 文章标签： docker 容器
于 2023-12-01 12:43:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54673740/article/details/134731886
版权

Docker 搭建 Minio 容器 (完整详细版)

简介：

Minio 是一个基于Apache License v2.0开源协议的对象存储服务，虽然轻量，却拥有着不错的性能。它兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据。

例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几 kb 到最大 5T 不等。

最重要的是免费

说明：

Docker如果想安装软件 , 必须先到Docker镜像仓库下载镜像。

Docker官方镜像

1、寻找Minio镜像

image-20231129205553602

image-20231130160039562

2、下载Minio镜像

# 下载镜像
docker pull minio/minio

#查看镜像
docker images
命令描述
docker pull minio/minio下载最新版Minio镜像 (其实此命令就等同于 : docker pull minio/minio:latest )
docker pull minio/minio:RELEASE.2023-11-20T22-40-07Z.fips下载指定版本的Minio镜像 (xxx指具体版本号)

image-20231129210410277

3、创建目录

一个用来存放配置，一个用来存储上传文件的目录

启动前需要先创建Minio外部挂载的配置文件（ /opt/minio/config）,和存储上传文件的目录（ /opt/minio/data）

mkdir -p /opt/minio/config

mkdir -p /opt/minio/data

4、创建Minio容器并运行

docker run \
-p 19000:9000 \
-p 9090:9090 \
--net=host \
--name minio \
-d --restart=always \
-e "MINIO_ACCESS_KEY=minioadmin" \
-e "MINIO_SECRET_KEY=minioadmin" \
-v /opt/minio/data:/data \
-v /opt/minio/config:/root/.minio \
 minio/minio server \
/data --console-address ":9090" -address ":19000"
命令描述
-p 9000:9000 -p 9090:9090这是端口映射，前一个是服务器的端口，后一个是客户端也就是api接口访问的端口地址
–name minio这是给新创建的容器命名的选项，名字是 “minio”
–net=host这是网络设置，表示容器将使用主机的网络栈，这样就不需要在容器内部配置网络
-d --restart=always这是运行容器的其他选项，-d使容器在后台运行，–restart=always表示容器总是会在退出后自动重启
-e “MINIO_ACCESS_KEY=minioadmin”用户名
-e “MINIO_SECRET_KEY=minioadmin”密码
-v /opt/minio/data:/data这意味着将宿主机上的 /opt/minio/data 目录挂载到容器内的 /data 目录
-v /opt/minio/config:/root/.minio将宿主机上的 /opt/minio/config 目录挂载到容器内的 /root/.minio 目录
minio/minio server /data --console-address “:9090” -address “:9000”这是容器内要运行的命令，启动一个名为 “minio” 的服务器，数据存储在 /data 目录下，服务器的控制台地址为 “:9090”，服务地址为 “:9000”
\换行
4.1、访问操作

访问：http://47.117.160.102:9090/login 用户名：密码 minioadmin：minioadmin

image-20231130165641764

4.2、创建用户

image-20231130173302737

image-20231130173436591

4.3、创建组

image-20231130173619690

image-20231130173728073

4.4、创建Buckets

image-20231130195452040

image-20231130195548997

4.5、创建Access Keys

image-20231130195953522

4.6、文件上传

image-20231201195412713

4.6、浏览器访问上传文件

image-20231201195651424

4.6.1、输入ip:19000/Buckets名/文件名，如果不行，看看端口是否开放

image-20231201195743467

5、Springboot简单使用

5.1、添加MinIO依赖Pom
<dependencies>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- MinIO 客户端 -->
        <dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <version>8.5.7</version>
        </dependency>
    
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.11</version>
        </dependency>
    
</dependencies>
5.2、配置MinIO的yaml
server:
  port: 3333

spring:
  servlet:
    multipart:
      max-request-size: 200MB
      max-file-size: 200MB

minio:
  url: http://127.0.0.1:19000 #换成自己的minio服务端地址
  accessKey: minioadmin # 用户名
  secretKey: minioadmin # 密码
  bucketName: demo  # bucketName指的就是之前创建的MinIO桶Bucket
5.3、配置类Config
/**
 * @author HAOYANG
 * @create 2023-12-01 20:40
 */
@Data
@Configuration
public class MinioConfig {

    /**
     * 访问地址
     */
    @Value("${minio.url}")
    private String endpoint;

    /**
     * accessKey类似于用户ID，用于唯一标识你的账户
     */
    @Value("${minio.accessKey}")
    private String accessKey;

    /**
     * secretKey是你账户的密码
     */
    @Value("${minio.secretKey}")
    private String secretKey;

    /**
     * 默认存储桶
     */
    @Value("${minio.bucketName}")
    private String bucketName;

    @Bean
    public MinioClient minioClient() {
        MinioClient minioClient = MinioClient.builder()
                .endpoint(endpoint)
                .credentials(accessKey, secretKey)
                .build();
        return minioClient;
    }
}
5.4、创建MinIO工具类
/**
 * MinIO工具类
 *
 */
@Slf4j
@Component
@RequiredArgsConstructor
public class MinioUtils {

    private final MinioClient minioClient;

    /******************************  Operate Bucket Start  ******************************/

    /**
     * 启动SpringBoot容器的时候初始化Bucket
     * 如果没有Bucket则创建
     *
     * @param bucketName
     */
    @SneakyThrows(Exception.class)
    private void createBucket(String bucketName) {
        if (!bucketExists(bucketName)) {
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
        }
    }

    /**
     * 判断Bucket是否存在，true：存在，false：不存在
     *
     * @param bucketName
     * @return
     */
    @SneakyThrows(Exception.class)
    public boolean bucketExists(String bucketName) {
        return minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
    }

    /**
     * 获得Bucket的策略
     *
     * @param bucketName
     * @return
     */
    @SneakyThrows(Exception.class)
    public String getBucketPolicy(String bucketName) {
        return minioClient.getBucketPolicy(GetBucketPolicyArgs
                .builder()
                .bucket(bucketName)
                .build());
    }

    /**
     * 获得所有Bucket列表
     *
     * @return
     */
    @SneakyThrows(Exception.class)
    public List<Bucket> getAllBuckets() {
        return minioClient.listBuckets();
    }

    /**
     * 根据bucketName获取其相关信息
     *
     * @param bucketName
     * @return
     */
    @SneakyThrows(Exception.class)
    public Optional<Bucket> getBucket(String bucketName) {
        return getAllBuckets().stream().filter(b -> b.name().equals(bucketName)).findFirst();
    }

    /**
     * 根据bucketName删除Bucket，true：删除成功； false：删除失败，文件或已不存在
     *
     * @param bucketName
     * @throws Exception
     */
    @SneakyThrows(Exception.class)
    public void removeBucket(String bucketName) {
        minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
    }

    /******************************  Operate Bucket End  ******************************/


    /******************************  Operate Files Start  ******************************/

    /**
     * 判断文件是否存在
     *
     * @param bucketName
     * @param objectName
     * @return
     */
    public boolean isObjectExist(String bucketName, String objectName) {
        boolean exist = true;
        try {
            minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build());
        } catch (Exception e) {
            log.error("[Minio工具类]>>>> 判断文件是否存在, 异常：", e);
            exist = false;
        }
        return exist;
    }

    /**
     * 判断文件夹是否存在
     *
     * @param bucketName
     * @param objectName
     * @return
     */
    public boolean isFolderExist(String bucketName, String objectName) {
        boolean exist = false;
        try {
            Iterable<Result<Item>> results = minioClient.listObjects(
                    ListObjectsArgs.builder().bucket(bucketName).prefix(objectName).recursive(false).build());
            for (Result<Item> result : results) {
                Item item = result.get();
                if (item.isDir() && objectName.equals(item.objectName())) {
                    exist = true;
                }
            }
        } catch (Exception e) {
            log.error("[Minio工具类]>>>> 判断文件夹是否存在，异常：", e);
            exist = false;
        }
        return exist;
    }

    /**
     * 根据文件前置查询文件
     *
     * @param bucketName 存储桶
     * @param prefix     前缀
     * @param recursive  是否使用递归查询
     * @return MinioItem 列表
     */
    @SneakyThrows(Exception.class)
    public List<Item> getAllObjectsByPrefix(String bucketName,
                                            String prefix,
                                            boolean recursive) {
        List<Item> list = new ArrayList<>();
        Iterable<Result<Item>> objectsIterator = minioClient.listObjects(
                ListObjectsArgs.builder().bucket(bucketName).prefix(prefix).recursive(recursive).build());
        if (objectsIterator != null) {
            for (Result<Item> o : objectsIterator) {
                Item item = o.get();
                list.add(item);
            }
        }
        return list;
    }

    /**
     * 获取文件流
     *
     * @param bucketName 存储桶
     * @param objectName 文件名
     * @return 二进制流
     */
    @SneakyThrows(Exception.class)
    public InputStream getObject(String bucketName, String objectName) {
        return minioClient.getObject(
                GetObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .build());
    }

    /**
     * 断点下载
     *
     * @param bucketName 存储桶
     * @param objectName 文件名称
     * @param offset     起始字节的位置
     * @param length     要读取的长度
     * @return 二进制流
     */
    @SneakyThrows(Exception.class)
    public InputStream getObject(String bucketName, String objectName, long offset, long length) {
        return minioClient.getObject(
                GetObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .offset(offset)
                        .length(length)
                        .build());
    }

    /**
     * 获取路径下文件列表
     *
     * @param bucketName 存储桶
     * @param prefix     文件名称
     * @param recursive  是否递归查找，false：模拟文件夹结构查找
     * @return 二进制流
     */
    public Iterable<Result<Item>> listObjects(String bucketName, String prefix, boolean recursive) {
        return minioClient.listObjects(
                ListObjectsArgs.builder()
                        .bucket(bucketName)
                        .prefix(prefix)
                        .recursive(recursive)
                        .build());
    }

    /**
     * 使用MultipartFile进行文件上传
     *
     * @param bucketName  存储桶
     * @param file        文件名
     * @param objectName  对象名
     * @param contentType 类型
     * @return
     */
    @SneakyThrows(Exception.class)
    public ObjectWriteResponse uploadFile(String bucketName, MultipartFile file, String objectName, String contentType) {
        InputStream inputStream = file.getInputStream();
        return minioClient.putObject(
                PutObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .contentType(contentType)
                        .stream(inputStream, inputStream.available(), -1)
                        .build());
    }

    /**
     * 图片上传
     * @param bucketName
     * @param imageBase64
     * @param imageName
     * @return
     */
    public ObjectWriteResponse uploadImage(String bucketName, String imageBase64, String imageName) {
        if (!StringUtils.isEmpty(imageBase64)) {
            InputStream in = base64ToInputStream(imageBase64);
            String newName = System.currentTimeMillis() + "_" + imageName + ".jpg";
            String year = String.valueOf(new Date().getYear());
            String month = String.valueOf(new Date().getMonth());
            return uploadFile(bucketName, year + "/" + month + "/" + newName, in);

        }
        return null;
    }
// BASE64Decoder在jdk8以上的版本移除了，报错最简单解决换成jdk8就行了
    public static InputStream base64ToInputStream(String base64) {
        ByteArrayInputStream stream = null;
        try {
            byte[] bytes = new BASE64Decoder().decodeBuffer(base64.trim());
            stream = new ByteArrayInputStream(bytes);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return stream;
    }


    /**
     * 上传本地文件
     *
     * @param bucketName 存储桶
     * @param objectName 对象名称
     * @param fileName   本地文件路径
     * @return
     */
    @SneakyThrows(Exception.class)
    public ObjectWriteResponse uploadFile(String bucketName, String objectName, String fileName) {
        return minioClient.uploadObject(
                UploadObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .filename(fileName)
                        .build());
    }

    /**
     * 通过流上传文件
     *
     * @param bucketName  存储桶
     * @param objectName  文件对象
     * @param inputStream 文件流
     * @return
     */
    @SneakyThrows(Exception.class)
    public ObjectWriteResponse uploadFile(String bucketName, String objectName, InputStream inputStream) {
        return minioClient.putObject(
                PutObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .stream(inputStream, inputStream.available(), -1)
                        .build());
    }

    /**
     * 创建文件夹或目录
     *
     * @param bucketName 存储桶
     * @param objectName 目录路径
     * @return
     */
    @SneakyThrows(Exception.class)
    public ObjectWriteResponse createDir(String bucketName, String objectName) {
        return minioClient.putObject(
                PutObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .stream(new ByteArrayInputStream(new byte[]{}), 0, -1)
                        .build());
    }

    /**
     * 获取文件信息, 如果抛出异常则说明文件不存在
     *
     * @param bucketName 存储桶
     * @param objectName 文件名称
     * @return
     */
    @SneakyThrows(Exception.class)
    public String getFileStatusInfo(String bucketName, String objectName) {
        return minioClient.statObject(
                StatObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .build()).toString();
    }

    /**
     * 拷贝文件
     *
     * @param bucketName    存储桶
     * @param objectName    文件名
     * @param srcBucketName 目标存储桶
     * @param srcObjectName 目标文件名
     */
    @SneakyThrows(Exception.class)
    public ObjectWriteResponse copyFile(String bucketName, String objectName, String srcBucketName, String srcObjectName) {
        return minioClient.copyObject(
                CopyObjectArgs.builder()
                        .source(CopySource.builder().bucket(bucketName).object(objectName).build())
                        .bucket(srcBucketName)
                        .object(srcObjectName)
                        .build());
    }

    /**
     * 删除文件
     *
     * @param bucketName 存储桶
     * @param objectName 文件名称
     */
    @SneakyThrows(Exception.class)
    public void removeFile(String bucketName, String objectName) {
        minioClient.removeObject(
                RemoveObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .build());
    }

    /**
     * 批量删除文件
     *
     * @param bucketName 存储桶
     * @param keys       需要删除的文件列表
     * @return
     */
    public void removeFiles(String bucketName, List<String> keys) {
        List<DeleteObject> objects = new LinkedList<>();
        keys.forEach(s -> {
            objects.add(new DeleteObject(s));
            try {
                removeFile(bucketName, s);
            } catch (Exception e) {
                log.error("[Minio工具类]>>>> 批量删除文件，异常：", e);
            }
        });
    }

    /**
     * 获取文件外链
     *
     * @param bucketName 存储桶
     * @param objectName 文件名
     * @param expires    过期时间 <=7 秒 （外链有效时间（单位：秒））
     * @return url
     */
    @SneakyThrows(Exception.class)
    public String getPresignedObjectUrl(String bucketName, String objectName, Integer expires) {
        GetPresignedObjectUrlArgs args = GetPresignedObjectUrlArgs.builder().expiry(expires).bucket(bucketName).object(objectName).build();
        return minioClient.getPresignedObjectUrl(args);
    }

    /**
     * 获得文件外链
     *
     * @param bucketName
     * @param objectName
     * @return url
     */
    @SneakyThrows(Exception.class)
    public String getPresignedObjectUrl(String bucketName, String objectName) {
        GetPresignedObjectUrlArgs args = GetPresignedObjectUrlArgs.builder()
                .bucket(bucketName)
                .object(objectName)
                .method(Method.GET).build();
        return minioClient.getPresignedObjectUrl(args);
    }

    /**
     * 将URLDecoder编码转成UTF8
     *
     * @param str
     * @return
     * @throws UnsupportedEncodingException
     */
    public String getUtf8ByURLDecoder(String str) throws UnsupportedEncodingException {
        String url = str.replaceAll("%(?![0-9a-fA-F]{2})", "%25");
        return URLDecoder.decode(url, "UTF-8");
    }
}
5.5、创建Controller
/**
 * @author HAOYANG
 * @create 2023-12-01 20:38
 */
@Slf4j
@RestController
@RequestMapping("/oss")
public class OSSController {

    @Autowired
    private MinioUtils minioUtils;

    @Autowired
    private MinioConfig minioConfig;

    /**
     * 文件上传
     *
     * @param file
     */
    @PostMapping("/upload")
    public String upload(@RequestParam("file") MultipartFile file) {
        try {
            //文件名
            String fileName = file.getOriginalFilename();
            String newFileName = System.currentTimeMillis() + "." + StringUtils.substringAfterLast(fileName, ".");
            //类型
            String contentType = file.getContentType();
            minioUtils.uploadFile(minioConfig.getBucketName(), file, newFileName, contentType);
            return "上传成功";
        } catch (Exception e) {
            log.error("上传失败");
            return "上传失败";
        }
    }

    /**
     * 删除
     *
     * @param fileName
     */
    @DeleteMapping("/")
    public void delete(@RequestParam("fileName") String fileName) {
        minioUtils.removeFile(minioConfig.getBucketName(), fileName);
    }

    /**
     * 获取文件信息
     *
     * @param fileName
     * @return
     */
    @GetMapping("/info")
    public String getFileStatusInfo(@RequestParam("fileName") String fileName) {
        return minioUtils.getFileStatusInfo(minioConfig.getBucketName(), fileName);
    }

    /**
     * 获取文件外链
     *
     * @param fileName
     * @return
     */
    @GetMapping("/url")
    public String getPresignedObjectUrl(@RequestParam("fileName") String fileName) {
        return minioUtils.getPresignedObjectUrl(minioConfig.getBucketName(), fileName);
    }

    /**
     * 文件下载
     *
     * @param fileName
     * @param response
     */
    @GetMapping("/download")
    public void download(@RequestParam("fileName") String fileName, HttpServletResponse response) {
        try {
            InputStream fileInputStream = minioUtils.getObject(minioConfig.getBucketName(), fileName);
            response.setHeader("Content-Disposition", "attachment;filename=" + fileName);
            response.setContentType("application/force-download");
            response.setCharacterEncoding("UTF-8");
            IOUtils.copy(fileInputStream, response.getOutputStream());
        } catch (Exception e) {
            log.error("下载失败");
        }
    }

}

6、测试验证

6.1、文件上传

使用Postman调用http://localhost:3333/oss/upload 接口，选择某个文件测试上传功能，如下图所示：

image-20231201213316663

6.2、文件下载

在浏览器中，调用http://localhost:3333/oss/download?fileName=1701436432918.gif 接口，验证文件下载接口，如下图所示：

image-20231201213607507

更多精彩文章可以关注 鹏摇星海 公众号
@昊阳
关注
  • 40
    点赞
  • 踩
  • 114
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
Docker 搭建 Minio 对象存储服务
小陈的博客
03-16 2646
整理了一套《前端大厂面试宝典》，包含了HTML、CSS、JavaScript、HTTP、TCP协议、浏览器、VUE、React、数据结构和算法，一共201道面试题，并对每个问题作出了回答和解析。
minio分布式部署搭建文档及安装程序
02-16
提供的`minio分布式部署搭建文档.docx`应该详细介绍了每个步骤，包括服务器配置、集群设置、安全策略等。务必仔细阅读并按照文档操作。同时，官方文档也是重要的参考资料，包含了丰富的教程和API参考。 总结来说，...
Docker部署Minio (服务器上部署Minio)
热门推荐
qq_63055262的博客
05-01 1万+
使用Docker在服务器上快速部署Minio的参考教程
【Docker】Minio 容器化部署配置详情
Qinghub‘博客
03-09 2183
qingtcloud-oss标准软件基于Bitnami minio 构建。当前版本为2024.2.26。
Docker 部署 Minio 对象存储服务器
最新发布
心若有所向往，何惧道阻且长。
07-02 1105
Docker 部署 Minio 对象存储服务器
Minio是什么
2023年最新地推相关信息
04-28 1130
Minio 是一个基于 Apache License v2.0 开源协议的对象存储服务。它兼容亚马逊 S3 云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几 kb 到最大 5T 不等。MinioMinio 是一个非常轻量的服务,可以很简单的和其他应用的结合，类似 NodeJS, Redis 或者 MySQ...
Docker安装MinIO
packge的博客
12-23 2715
1、MinIO 是在 Apache License v2.0 下发布的对象存储服务器。它与 Amazon S3 云存储服务兼容。它最适合存储非结构化数据，如照片，视频，日志文件，备份和容器/ VM 映像。对象的大小可以从几 KB 到最大 5TB。2、MinIO 服务器足够轻，可以与应用程序堆栈捆绑在一起，类似于 NodeJS，Redis 和 MySQL3 一种高性能的分布式对象存储服务器，用于大型数据基础设施。它是机器学习和其他大数据工作负载下Hadoop HDFS 的理想 s3 兼容替代品。
docker 搭建minio容器（精简版）
weixin_63326871的博客
12-11 443
docker 搭建minio容器（精简版）
Docker搭建MinIO
LogicLancer的博客
03-29 801
MinIO 是一个高性能的分布式对象存储服务，它兼容亚马逊S3云存储服务。MinIO 适用于存储非结构化数据，例如照片、视频、日志文件等。它具有高可用性、扩展性强和安装简单等特点。本教程将介绍如何使用 Docker CLI 和 Docker Compose 两种方式来搭建 MinIO 分布式存储服务。
Docker搭建minio文件服务器
赵广陆
08-03 501
一、获取镜像 docker pull minio/minio 二、构建容器 docker run -p 9000:9000 --name minio -d --restart=always -e "MINIO_ACCESS_KEY=admin" -e "MINIO_SECRET_KEY=admin123456" -v /home/data:/data -v /home/config:/root/.minio minio/minio server /data -p：端口映射 -name：容器名称 -e：环
docker搭建minio
Gang-bb的博客
11-12 837
1.分布式文件系统应用场景 互联网海量非结构化数据的存储需求 电商网站：海量商品图片 视频网站：海量视频文件 网盘：海量文件 社交网站：海量图片 2. minio安装 Minio官网：https://min.io/ docker run \ -p 9000:9000 \ -p 9001:9001 \ -d --restart=always \ -e "MINIO_ROOT_USER=admin" \ -e "MINIO_ROOT_PASSWORD=admin123456" \ -
阿里云部署笔记（含Docker运行MySQL、Nacos、Redis、Minio、MongoDB容器）
06-06
阿里云部署笔记（含Docker运行MySQL、Nacos、Redis、Minio、MongoDB容器）
搭建Harbor2.x 最新版私有镜像仓库-docker私仓
06-05
harbor-offline-installer-v2.5.1 github下载的安装包。网速不好的小伙伴可以下载奥
使用MinIO搭建对象存储服务.doc
07-08
然后，使用 Docker 运行 MinIO 容器，并设置 MINIO_ACCESS_KEY 和 MINIO_SECRET_KEY。 MinIO 的安装步骤 1. 下载 MinIO 的镜像 2. 运行 MinIO 容器 3. 访问 MinIO 的 Web 界面 4. 创建一个 Bucket 5. 创建一个 ...
私有化对象存储服务器搭建软件MinIO
06-11
MinIO是一款开源的对象存储服务器，特别适合用于搭建私有化的云存储解决方案。它设计的目标是提供高可用性、高性能和可扩展性，适用于大数据、容器化环境和边缘计算场景。MinIO采用现代化的Go语言编写，因此具备轻量...
Docker部署MinIO分布式存储系统+SpringBoot整合MinIO
阿木木AEcru的博客
02-24 2065
中文官网MinIO Container中文文档Minio是一个高性能、分布式对象存储系统，兼容Amazon S3 API。它可以通过搭建私有云来提供存储服务，也可以作为公共云中的对象存储服务。Minio的实现原理是基于分布式的架构，数据被分割为多个部分并存储在不同的服务器上。这些服务器通过一个一致性哈希算法将数据划分为不同的分片，并且使用Erasure Coding来提供数据冗余和容错能力。客户端通过S3协议与Minio进行交互，可以像操作Amazon S3一样进行数据的上传、下载、删除等操作。
【Docker】手把手教你在windows使用Docker安装Minio[详细教程]
m0_64210833的博客
06-15 4717
手把手教你在windows使用Docker安装Minio[详细教程]
docker搭建minio分布式集群详细步骤
05-27
好的，下面是使用docker搭建minio分布式集群的详细步骤： 1. 安装Docker和Docker Compose 您需要在您的机器上安装Docker和Docker Compose。如果您还没有安装，请先安装。 2. 创建docker-compose.yml文件 在您的工作目录下创建一个名为docker-compose.yml的文件，并将以下内容复制到文件中。 ``` version: '3' services: minio1: image: minio/minio container_name: minio1 command: server http://minio{1...4}/data{1...4} ports: - "9001:9000" volumes: - ./data1:/data1 environment: MINIO_ACCESS_KEY: YOUR_ACCESS_KEY MINIO_SECRET_KEY: YOUR_SECRET_KEY restart: always minio2: image: minio/minio container_name: minio2 command: server http://minio{1...4}/data{1...4} ports: - "9002:9000" volumes: - ./data2:/data2 environment: MINIO_ACCESS_KEY: YOUR_ACCESS_KEY MINIO_SECRET_KEY: YOUR_SECRET_KEY restart: always minio3: image: minio/minio container_name: minio3 command: server http://minio{1...4}/data{1...4} ports: - "9003:9000" volumes: - ./data3:/data3 environment: MINIO_ACCESS_KEY: YOUR_ACCESS_KEY MINIO_SECRET_KEY: YOUR_SECRET_KEY restart: always minio4: image: minio/minio container_name: minio4 command: server http://minio{1...4}/data{1...4} ports: - "9004:9000" volumes: - ./data4:/data4 environment: MINIO_ACCESS_KEY: YOUR_ACCESS_KEY MINIO_SECRET_KEY: YOUR_SECRET_KEY restart: always ``` 3. 启动集群 在您的工作目录中运行以下Docker Compose命令，以启动Minio集群。 ``` docker-compose up -d ``` 这将在您的机器上启动四个Minio容器，每个容器都有一个自己的数据卷，并且它们都在同一网络中。 4. 访问Minio UI 您可以在浏览器中访问http://localhost:9001/，并使用您的访问密钥和秘密密钥登录Minio UI。您将看到一个名为“data1”的存储桶已经被创建。 5. 添加其他节点 如果您需要添加其他节点，请在docker-compose.yml文件中添加另一个服务，并使用相同的access key和secret key。您还需要在Minio UI中添加新的节点。 这些是使用Docker Compose搭建Minio分布式集群的基本步骤。如果您需要更详细的指导，请查看Minio官方文档。
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值