OSS对比MinIO

已于 2024-04-23 16:59:40 修改
阅读量2.2k 收藏 19
点赞数 13
CC 4.0 BY-SA版权
文章标签： java
于 2024-04-23 14:54:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_57554093/article/details/138117534

概念

OSS（Object Storage Service）：

  • OSS是阿里云提供的对象存储服务，主要用于存储大规模的非结构化数据，例如图片、视频、文档等。它采用了分布式存储架构，可以实现高可用性和高可靠性。
  • OSS支持通过API接口、SDK等方式进行数据上传、下载和管理，同时提供了数据安全、数据备份等功能，适用于各种云计算场景和大数据应用。

MinIO：

  • MinIO是一个高性能的开源对象存储服务，支持标准的S3 API，可以部署在本地服务器、私有云或公有云上。它的设计目标是提供高性能、可扩展的对象存储解决方案。
  • MinIO以轻量化和高度可定制性著称，可以快速部署并与各种应用程序集成。它具有良好的性能表现，适合用于存储大规模的数据、处理高并发请求等场景。

S3 API：

  • S3 API是指Amazon Simple Storage Service（Amazon S3）提供的应用程序编程接口（API），它允许开发者和系统管理员以编程方式管理Amazon S3上的数据。S3 API是一套RESTful接口，通过它，用户可以在Amazon S3上执行各种操作，如创建和删除存储桶（Buckets），上传、下载和删除对象（Objects），以及设置对象和存储桶的权限等。
  • MinIO是基于S3 API实现的，它提供了与Amazon S3兼容的API，这意味着任何支持S3 API的客户端或应用程序理论上都可以无缝地与MinIO进行交互，而无需修改代码。

使用

OSS（参考 阿里云文档）：

创建存储空间

存储空间是OSS的全局命名空间，相当于数据的容器，可以存储若干文件。以下代码用于创建存储空间。

代码运行成功后，将创建名为 examplebucket 的存储空间。

import com.aliyun.oss.ClientException;
import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.OSSException;
import com.aliyun.oss.common.auth.CredentialsProviderFactory;
import com.aliyun.oss.common.auth.EnvironmentVariableCredentialsProvider;

public class Demo {

    public static void main(String[] args) throws Exception {
         // Endpoint以华东1（杭州）为例，其它Region请按实际情况填写。
        String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
        // 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        // 填写Bucket名称，例如examplebucket。Bucket名称在OSS范围内必须全局唯一。
        String bucketName = "examplebucket";

        // 创建OSSClient实例。
        OSS ossClient = new OSSClientBuilder().build(endpoint, credentialsProvider);

        try {
            // 创建存储空间。
            ossClient.createBucket(bucketName);

        } catch (OSSException oe) {
            System.out.println("Caught an OSSException, which means your request made it to OSS, "
                    + "but was rejected with an error response for some reason.");
            System.out.println("Error Message:" + oe.getErrorMessage());
            System.out.println("Error Code:" + oe.getErrorCode());
            System.out.println("Request ID:" + oe.getRequestId());
            System.out.println("Host ID:" + oe.getHostId());
        } catch (ClientException ce) {
            System.out.println("Caught an ClientException, which means the client encountered "
                    + "a serious internal problem while trying to communicate with OSS, "
                    + "such as not being able to access the network.");
            System.out.println("Error Message:" + ce.getMessage());
        } finally {
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }
    }
}

上传文件

以下代码用于通过流式上传的方式将文件上传到OSS。

代码运行成功后，exampledir 目录下将上传 exampleobject.txt 文件。

import com.aliyun.oss.ClientException;
import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.OSSException;
import com.aliyun.oss.common.auth.CredentialsProviderFactory;
import com.aliyun.oss.common.auth.EnvironmentVariableCredentialsProvider;
import java.io.ByteArrayInputStream;

public class Demo {

    public static void main(String[] args) throws Exception {
        // Endpoint以华东1（杭州）为例，其它Region请按实际情况填写。
        String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
        // 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        // 填写Bucket名称，例如examplebucket。
        String bucketName = "examplebucket";
        // 填写Object完整路径，例如exampledir/exampleobject.txt。Object完整路径中不能包含Bucket名称。
        String objectName = "exampledir/exampleobject.txt";

        // 创建OSSClient实例。
        OSS ossClient = new OSSClientBuilder().build(endpoint, credentialsProvider);

        try {
            String content = "Hello OSS";
            ossClient.putObject(bucketName, objectName, new ByteArrayInputStream(content.getBytes()));
        } catch (OSSException oe) {
            System.out.println("Caught an OSSException, which means your request made it to OSS, "
                    + "but was rejected with an error response for some reason.");
            System.out.println("Error Message:" + oe.getErrorMessage());
            System.out.println("Error Code:" + oe.getErrorCode());
            System.out.println("Request ID:" + oe.getRequestId());
            System.out.println("Host ID:" + oe.getHostId());
        } catch (ClientException ce) {
            System.out.println("Caught an ClientException, which means the client encountered "
                    + "a serious internal problem while trying to communicate with OSS, "
                    + "such as not being able to access the network.");
            System.out.println("Error Message:" + ce.getMessage());
        } finally {
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }
    }
}

下载文件

以下代码用于通过流式下载方式从OSS下载文件。

代码运行成功后，编译工具中将显示下载的文件内容。

import com.aliyun.oss.ClientException;
import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.OSSException;
import com.aliyun.oss.common.auth.CredentialsProviderFactory;
import com.aliyun.oss.common.auth.EnvironmentVariableCredentialsProvider;
import com.aliyun.oss.model.OSSObject;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;

public class Demo {

    public static void main(String[] args) throws Exception {
        // Endpoint以华东1（杭州）为例，其它Region请按实际情况填写。
        String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
        // 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        // 填写Bucket名称，例如examplebucket。
        String bucketName = "examplebucket";
        // 填写Object完整路径，例如exampledir/exampleobject.txt。Object完整路径中不能包含Bucket名称。
        String objectName = "exampledir/exampleobject.txt";

        // 创建OSSClient实例。
        OSS ossClient = new OSSClientBuilder().build(endpoint, credentialsProvider);

        try {
            // 调用ossClient.getObject返回一个OSSObject实例，该实例包含文件内容及文件元数据。
            OSSObject ossObject = ossClient.getObject(bucketName, objectName);
            // 调用ossObject.getObjectContent获取文件输入流，可读取此输入流获取其内容。
            InputStream content = ossObject.getObjectContent();
            if (content != null) {
                BufferedReader reader = new BufferedReader(new InputStreamReader(content));
                while (true) {
                    String line = reader.readLine();
                    if (line == null) {
                      break;
                    }
                    System.out.println("\n" + line);
                }
                // 数据读取完成后，获取的流必须关闭，否则会造成连接泄漏，导致请求无连接可用，程序无法正常工作。
                content.close();
            }
        } catch (OSSException oe) {
            System.out.println("Caught an OSSException, which means your request made it to OSS, "
                    + "but was rejected with an error response for some reason.");
            System.out.println("Error Message:" + oe.getErrorMessage());
            System.out.println("Error Code:" + oe.getErrorCode());
            System.out.println("Request ID:" + oe.getRequestId());
            System.out.println("Host ID:" + oe.getHostId());
        } catch (ClientException ce) {
            System.out.println("Caught an ClientException, which means the client encountered "
                    + "a serious internal problem while trying to communicate with OSS, "
                    + "such as not being able to access the network.");
            System.out.println("Error Message:" + ce.getMessage());
        } finally {
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }
    }
}

列举文件

以下代码用于列举存储空间bucket下的文件。默认列举100个文件。

代码运行成功后，编译工具中将显示列举的文件详情，例如 exampledir/exampleobject.txt 。

import com.aliyun.oss.ClientException;
import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.OSSException;
import com.aliyun.oss.common.auth.CredentialsProviderFactory;
import com.aliyun.oss.common.auth.EnvironmentVariableCredentialsProvider;
import com.aliyun.oss.model.OSSObjectSummary;
import com.aliyun.oss.model.ObjectListing;

public class Demo {

    public static void main(String[] args) throws Exception {
        // Endpoint以华东1（杭州）为例，其它Region请按实际情况填写。
        String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
        // 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        // 填写Bucket名称，例如examplebucket。
        String bucketName = "examplebucket";

        // 创建OSSClient实例。
        OSS ossClient = new OSSClientBuilder().build(endpoint, credentialsProvider);

        try {
            // ossClient.listObjects返回ObjectListing实例，包含此次listObject请求的返回结果。
            ObjectListing objectListing = ossClient.listObjects(bucketName);
            // objectListing.getObjectSummaries获取所有文件的描述信息。
            for (OSSObjectSummary objectSummary : objectListing.getObjectSummaries()) {
                System.out.println(" - " + objectSummary.getKey() + "  " +
                        "(size = " + objectSummary.getSize() + ")");
            }
        } catch (OSSException oe) {
            System.out.println("Caught an OSSException, which means your request made it to OSS, "
                    + "but was rejected with an error response for some reason.");
            System.out.println("Error Message:" + oe.getErrorMessage());
            System.out.println("Error Code:" + oe.getErrorCode());
            System.out.println("Request ID:" + oe.getRequestId());
            System.out.println("Host ID:" + oe.getHostId());
        } catch (ClientException ce) {
            System.out.println("Caught an ClientException, which means the client encountered "
                    + "a serious internal problem while trying to communicate with OSS, "
                    + "such as not being able to access the network.");
            System.out.println("Error Message:" + ce.getMessage());
        } finally {
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }
    }
}

删除文件

以下代码用于删除指定文件。

代码运行成功后，将删除 exampledir 目录下的 exampleobject.txt 文件。

import com.aliyun.oss.ClientException;
import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.OSSException;
import com.aliyun.oss.common.auth.CredentialsProviderFactory;
import com.aliyun.oss.common.auth.EnvironmentVariableCredentialsProvider;

public class Demo {

    public static void main(String[] args) throws Exception {
        // Endpoint以华东1（杭州）为例，其它Region请按实际情况填写。
        String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
        // 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        // 填写Bucket名称，例如examplebucket。
        String bucketName = "examplebucket";
        // 填写Object完整路径，例如exampledir/exampleobject.txt。Object完整路径中不能包含Bucket名称。
        String objectName = "exampledir/exampleobject.txt";

        // 创建OSSClient实例。
        OSS ossClient = new OSSClientBuilder().build(endpoint, credentialsProvider);

        try {
            // 删除文件。
            ossClient.deleteObject(bucketName, objectName);
        } catch (OSSException oe) {
            System.out.println("Caught an OSSException, which means your request made it to OSS, "
                    + "but was rejected with an error response for some reason.");
            System.out.println("Error Message:" + oe.getErrorMessage());
            System.out.println("Error Code:" + oe.getErrorCode());
            System.out.println("Request ID:" + oe.getRequestId());
            System.out.println("Host ID:" + oe.getHostId());
        } catch (ClientException ce) {
            System.out.println("Caught an ClientException, which means the client encountered "
                    + "a serious internal problem while trying to communicate with OSS, "
                    + "such as not being able to access the network.");
            System.out.println("Error Message:" + ce.getMessage());
        } finally {
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }
    }
}

MinIO：

import io.minio.BucketExistsArgs;
import io.minio.DownloadObjectArgs;
import io.minio.MakeBucketArgs;
import io.minio.MinioClient;
import io.minio.RemoveObjectArgs;
import io.minio.UploadObjectArgs;
import io.minio.messages.Bucket;

public class MinioExample {

    public static void main(String[] args) {
        try {
            // 初始化Minio客户端
            MinioClient minioClient = MinioClient.builder()
                    .endpoint("http://minio.example.com") // MinIO服务器地址
                    .credentials("accessKey", "secretKey") // 访问密钥和密钥
                    .build();

            // 创建存储空间（Bucket）
            String bucketName = "example-bucket";
            boolean bucketExists = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
            if (!bucketExists) {
                minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
                System.out.println("Bucket created successfully: " + bucketName);
            }

            // 上传文件
            String objectName = "example-file.txt";
            String uploadFilePath = "/path/to/local/file.txt";
            minioClient.uploadObject(UploadObjectArgs.builder()
                    .bucket(bucketName)
                    .object(objectName)
                    .filename(uploadFilePath)
                    .build());
            System.out.println("File uploaded successfully: " + objectName);

            // 下载文件
            String downloadFilePath = "/path/to/local/downloaded-file.txt";
            minioClient.downloadObject(DownloadObjectArgs.builder()
                    .bucket(bucketName)
                    .object(objectName)
                    .filename(downloadFilePath)
                    .build());
            System.out.println("File downloaded successfully: " + objectName);

            // 列举文件
            Iterable<Bucket> buckets = minioClient.listBuckets();
            for (Bucket bucket : buckets) {
                System.out.println("Bucket Name: " + bucket.name());
            }

            // 删除文件
            minioClient.removeObject(RemoveObjectArgs.builder()
                    .bucket(bucketName)
                    .object(objectName)
                    .build());
            System.out.println("File deleted successfully: " + objectName);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

工具类封装

OSS

import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.model.Bucket;
import com.aliyun.oss.model.GetObjectRequest;
import com.aliyun.oss.model.ListObjectsRequest;
import com.aliyun.oss.model.OSSObjectSummary;
import com.aliyun.oss.model.ObjectListing;

import java.io.File;
import java.util.List;

public class OssUtil {

    private static OSS ossClient;

    static {
        try {
            String endpoint = "https://oss-cn-hangzhou.aliyuncs.com"; // OSS服务地址
            String accessKeyId = "yourAccessKeyId"; // 访问密钥ID
            String accessKeySecret = "yourAccessKeySecret"; // 访问密钥Secret
            // 初始化OSS客户端
            ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 创建存储空间（Bucket）
    public static void createBucket(String bucketName) {
        try {
            ossClient.createBucket(bucketName);
            System.out.println("Bucket created successfully: " + bucketName);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 上传文件
    public static void uploadFile(String bucketName, String objectName, String uploadFilePath) {
        try {
            ossClient.putObject(bucketName, objectName, new File(uploadFilePath));
            System.out.println("File uploaded successfully: " + objectName);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 下载文件
    public static void downloadFile(String bucketName, String objectName, String downloadFilePath) {
        try {
            ossClient.getObject(new GetObjectRequest(bucketName, objectName), new File(downloadFilePath));
            System.out.println("File downloaded successfully: " + objectName);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 列举存储桶
    public static void listBuckets() {
        try {
            List<Bucket> buckets = ossClient.listBuckets();
            for (Bucket bucket : buckets) {
                System.out.println("Bucket Name: " + bucket.getName());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 列举对象
    public static void listObjects(String bucketName) {
        try {
            ObjectListing objectListing = ossClient.listObjects(new ListObjectsRequest(bucketName));
            List<OSSObjectSummary> objectSummaries = objectListing.getObjectSummaries();
            for (OSSObjectSummary objectSummary : objectSummaries) {
                System.out.println("Object Key: " + objectSummary.getKey());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 删除文件
    public static void deleteFile(String bucketName, String objectName) {
        try {
            ossClient.deleteObject(bucketName, objectName);
            System.out.println("File deleted successfully: " + objectName);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        createBucket("example-bucket");
        uploadFile("example-bucket", "example-file.txt", "/path/to/local/upload-file.txt");
        downloadFile("example-bucket", "example-file.txt", "/path/to/local/download-file.txt");
        listBuckets();
        listObjects("example-bucket");
        deleteFile("example-bucket", "example-file.txt");
    }

}

MinIO

import io.minio.BucketExistsArgs;
import io.minio.DownloadObjectArgs;
import io.minio.ListObjectsArgs;
import io.minio.MakeBucketArgs;
import io.minio.MinioClient;
import io.minio.RemoveObjectArgs;
import io.minio.Result;
import io.minio.UploadObjectArgs;
import io.minio.messages.Bucket;
import io.minio.messages.Item;

public class MinioUtil {

    private static MinioClient minioClient;

    static {
        try {
            String endpoint = "https://minio.example.com"; // MinIO服务器地址
            String accessKey = "accessKey"; // 访问密钥
            String secretKey = "secretKey"; // 密钥
            // 初始化Minio客户端
            minioClient = MinioClient.builder()
                    .endpoint(endpoint)
                    .credentials(accessKey, secretKey)
                    .build();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 创建存储空间（Bucket）
    public static void createBucket(String bucketName) {
        try {
            if (!minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build())) {
                minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
                System.out.println("Bucket created successfully: " + bucketName);
            } else {
                System.out.println("Bucket already exists: " + bucketName);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 上传文件
    public static void uploadFile(String bucketName, String objectName, String uploadFilePath) {
        try {
            minioClient.uploadObject(UploadObjectArgs.builder()
                    .bucket(bucketName)
                    .object(objectName)
                    .filename(uploadFilePath)
                    .build());
            System.out.println("File uploaded successfully: " + objectName);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 下载文件
    public static void downloadFile(String bucketName, String objectName, String downloadFilePath) {
        try {
            minioClient.downloadObject(DownloadObjectArgs.builder()
                    .bucket(bucketName)
                    .object(objectName)
                    .filename(downloadFilePath)
                    .build());
            System.out.println("File downloaded successfully: " + objectName);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 列举存储桶
    public static void listBuckets() {
        try {
            Iterable<Bucket> buckets = minioClient.listBuckets();
            for (Bucket bucket : buckets) {
                System.out.println("Bucket Name: " + bucket.name());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 列举对象
    public static void listObjects(String bucketName) {
        try {
            Iterable<Result<Item>> listObjects = minioClient.listObjects(ListObjectsArgs.builder().bucket(bucketName).build());
            for (Result<Item> object : listObjects) {
                System.out.println(object.get().objectName());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 删除文件
    public static void deleteFile(String bucketName, String objectName) {
        try {
            minioClient.removeObject(RemoveObjectArgs.builder()
                    .bucket(bucketName)
                    .object(objectName)
                    .build());
            System.out.println("File deleted successfully: " + objectName);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        MinioUtil.createBucket("example-bucket");
        MinioUtil.uploadFile("example-bucket", "example-file.txt", "/path/to/local/upload-file.txt");
        MinioUtil.downloadFile("example-bucket", "example-file.txt", "/path/to/local/download-file.txt");
        MinioUtil.listBuckets();
        MinioUtil.listObjects("example-bucket");
        MinioUtil.deleteFile("example-bucket", "example-file.txt");
    }

}
**移不动
关注
什么？OSS存储你还在用FastDFS？MinIO了解一下！！！
SpringForAll的博客
05-06 8787
什么是MinIO ？ 根据官方定义： MinIO 是在 Apache License v2.0 下发布的对象存储服务器。 它与 Amazon S3 云存储服务兼容。 它最适合存储非结构化数据，如照片，视频，日志文件，备份和容器/ VM 映像。 对象的大小可以从几 KB 到最大 5TB。 MinIO 服务器足够轻，可以与应用程序堆栈捆绑在一起，类似于 NodeJS，Redis 和 MySQL。...
Minio 对象存储 OSS概述
奔走的蚂蚁的博客
05-16 1937
系列文章目录对象存储 OSS基本概念存储空间（Bucket）对象（Object）ObjectKeyRegion（地域）Endpoint（访问域名）AccessKey（访问密钥）强一致性数据冗余机制OSS与文件系统的对比应用场景图片和音视频等应用的海量存储网页或者移动应用的静态和动态资源分离云端数据处理。
MinlO以及阿里云OSS对象存储服务
pythontxt的博客
04-17 2940
MinIO是一个开源的对象存储系统，专为云原生和容器化环境而设计。它使用分布式架构来存储和管理大规模的非结构化数据，例如图片、视频、日志文件等。MinIO基于Amazon S3协议，并提供了与S3兼容的API，这使得它能够与现有的S3生态系统无缝集成。MinIO的特点包括高性能、简单、轻量级，以及对开发者友好。它认为存储应该是一个开发问题而不是一个运维问题。MinIO是Kubernetes的原生产品，是唯一一个可在每个公共云、每个Kubernetes发行版、私有云和边缘上使用的对象存储套件。
Minio分布式文件管理系统实现OSS功能
最新发布
2301_80362588的博客
05-26 359
minio的安装和配置，参考官网链接。
OSS服务和MinIO存储做一个区分解析
IT小辉同学
11-18 4104
日落金山，明天我们继续......
【SpringBoot】SpringBoot 集成 Minio、OSS
sco5282的博客
08-31 1257
MinIO 是一款基于 Go 语言发开的高性能、分布式的对象存储系统。简单来说：就是可以存视频、图片 等。可以创建一个 bucket。
分布式对象存储oss-minio
IT二叔的博客
09-01 2541
minio简介 MinIO 是在 Apache License v2.0 下发布的对象存储服务器。 它与 Amazon S3 云存储服务兼容。 它最适合存储非结构化数据，如照片，视频，日志文件，备份和容器/ VM 映像。 对象的大小可以从几 KB 到最大 5TB。 MinIO 服务器足够轻，可以与应用程序堆栈捆绑在一起，类似于 NodeJS，Redis 和 MySQL。 一种高性能的分布式对象存储服务器，用于大型数据基础设施。它是机器学习和其他大数 据工作负载下 Hadoop HDFS 的理想 s3 兼容
oss云存储API
04-26
阿里云存储服务（Open Storage Service，简称OSS），是阿里云对外提供的海量，安全，低成本，高可靠的 云存储服务。用户可以通过本文档提供的简单的REST接口，在任何时间、任何地点、任何互联网设备上进行上 传和...
minio和阿里云oss对比
04-04
Minio和阿里云OSS都是云存储服务，但是两者有以下不同： 1. 价格：Minio是开源软件，免费使用，但是需要自己购买服务器来搭建。阿里云OSS是按照存储量和流量计费（有免费额度），价格相对较高。 2. 功能：阿里云...
常用分布式文件系统(对象存储)对比-SeaweedFS、Minio
gaozhenzhai的博客
09-19 5036
所有文件的元数据不存储在Master节点，而是分散存储在Volume（逻辑卷，存储数据的逻辑结构）中，Master节点只保存卷 ID到卷服务器的映射，这样一来，Master节点的查询压力就被分散到volume节点了。对跨公网的文件同步，存在较大延迟，需要应用做相应的容错策略。minio是一款有明显优缺点的产品,在我们的需求背景下,minio不能够很好的满足,特别是不能够支持我们10亿+对象存储需求,而且在现有的架构设计下,也不太好改造,然后通过与社区共建的方式来满足我们海量小文件的需求。
对象存储(OSS)--MinIO--使用/教程/实例
IT利刃出鞘的博客
09-24 9784
本文介绍MinIO这个对象存储服务，包括：安装、前端页面的使用、文件永久有效的设置方法、Java操作MinIO的实例。
【分布式技术专题】「OSS中间件系列」从0到1的介绍一下开源对象存储MinIO技术架构
夏壹分享
08-25 2226
MinIO创始者是Anand Babu Periasamy, Harshavardhana（戒日王）等人， Anand是GlusterFS的初始开发者、Gluster公司的创始人与CTO，Harshavardhana曾经是GlusterFS的开发人员，直到2011年红帽收购了Gluster公司。MinIO在设计上汲取了GlusterFS的相关经验与教训，系统复杂度上作了大量简化。
nas、oss、minio笔记
enthan809882的博客
03-30 944
nas、oss、minio笔记
使用minio自行搭建oss系统，存储文件
爱码士的博客
01-12 5729
前言 你可以购买如阿里云、七牛云、腾讯云等oss产品，也可以在内部网络搭建。 minio 网站：https://docs.min.io/cn/ MinIO 是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几kb到最大5T不等。 MinIO是一个非常轻量的服务,可以很简单的和其他应用的结合，类似 NodeJS, Redis 或者 M
【分布式技术专题】「OSS中间件系列」Minio的文件服务的存储模型及整合Java客户端访问的实战指南
夏壹分享
08-28 1242
通过网关模式，MinIO对象存储后端，可以对接各种现有的常见其它存储类型，比如的NAS系统，微软Azure Blob 存储、Google 云存储、HDFS、阿里巴巴OSS、亚马逊S3等，非常有利于企业复用现有资源，有利于企业低成本（硬件成本约等于零，部署MinIO对象存储软件即可）地从现有系统平滑升级到对象存储。国内使用Ceph的厂商、基于Ceph进行自研的存储厂商都比较多，在使用过程中遇到的问题（有些时候，甚至需要修改、增强乃至重新实现Ceph本身的功能），可以向相关厂商寻求支持。
1、aws-sdk-go快速使用（minio和oss）
Salted fish in hand, I have the world.
07-22 2502
只要会话没有被修改，会话就可以安全地并发使用。创建会话后，SDK不会修改会话。从共享会话同时创建服务客户端是安全的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值