Minio开始收费了,这5种免费的分布式文件系统更香

// 假设你基于minio开发了一个文件管理服务
public class filemanagementservice {
    // 这段代码本身可能没问题...
    private minioclient minioclient;
    public void processuserfile(userfile file) {
        // 但是，如果你的整个服务基于agplv3代码
        // 根据严格解释，你可能需要开源整个项目
        minioclient.putobject(...);
        // 更多业务逻辑...
    }
}

# seaweedfs的部署简单到令人惊讶
# 1. 下载（只有一个二进制文件！）
wget https://github.com/seaweedfs/seaweedfs/releases/download/3.55/linux_amd64.tar.gz
tar -xzf linux_amd64.tar.gz
# 2. 启动主服务器（管理元数据）
./weed master -ip=localhost -port=9333
# 3. 启动存储节点
./weed volume -dir="./data" -max=100 -mserver="localhost:9333" -port=8080
# 就是这么简单！现在你已经有了一个分布式文件系统

// seaweedfs的java客户端使用示例
public class seaweedfsexample {
    // seaweedfs提供s3兼容接口，可以使用标准的aws sdk
    private amazons3 s3client;
    public void init() {
        // 配置连接到seaweedfs的filer组件（提供s3接口）
        awscredentials credentials = new basicawscredentials(
            "your-access-key",  // seaweedfs默认无需认证，但可以配置
            "your-secret-key"
        );
        s3client = amazons3clientbuilder.standard()
            .withendpointconfiguration(
                new awsclientbuilder.endpointconfiguration(
                    "http://localhost:8333",  // filer默认端口
                    "us-east-1"
                )
            )
            .withcredentials(new awsstaticcredentialsprovider(credentials))
            .withpathstyleaccessenabled(true)  // seaweedfs需要此设置
            .build();
    }
    // 上传文件到seaweedfs
    public void uploadfile(string bucketname, string objectkey, file file) {
        // 创建存储桶（如果需要）
        if (!s3client.doesbucketexistv2(bucketname)) {
            s3client.createbucket(bucketname);
        }
        // 上传文件
        s3client.putobject(bucketname, objectkey, file);
        system.out.println("文件已上传至seaweedfs");
        system.out.println("下载url: http://localhost:8333/" + bucketname + "/" + objectkey);
    }
    // seaweedfs特色功能：小文件合并存储
    public void uploadsmallfiles(list<file> smallfiles, string bucketname) {
        // seaweedfs内部会自动将小文件合并存储
        // 这大大提高了海量小文件的存储效率
        for (int i = 0; i < smallfiles.size(); i++) {
            file file = smallfiles.get(i);
            string objectkey = "small-file-" + i + "-" + file.getname();
            s3client.putobject(bucketname, objectkey, file);
        }
        system.out.println("已上传 " + smallfiles.size() + " 个小文件");
        system.out.println("seaweedfs会自动优化这些文件的存储");
    }
}

# docker-compose.yml - 3节点garage集群
version: '3.8'
services:
  garage1:
    image: dxflrs/garage:v0.9.0
    command: "garage server"
    environment:
      - garage_node_name=node1
      - garage_rpc_secret=my-secret-key
      - garage_bind_addr=0.0.0.0:3901
      - garage_rpc_bind_addr=0.0.0.0:3902
      - garage_replication_mode=3
    volumes:
      - ./data/garage1:/var/lib/garage
    ports:
      - "3901:3901"
      - "3902:3902"
  garage2:
    image: dxflrs/garage:v0.9.0
    command: "garage server"
    environment:
      - garage_node_name=node2
      - garage_rpc_secret=my-secret-key
      - garage_bind_addr=0.0.0.0:3901
      - garage_rpc_bind_addr=0.0.0.0:3902
      - garage_seed=garage1:3902
    volumes:
      - ./data/garage2:/var/lib/garage
  garage3:
    image: dxflrs/garage:v0.9.0
    command: "garage server"
    environment:
      - garage_node_name=node3
      - garage_rpc_secret=my-secret-key
      - garage_bind_addr=0.0.0.0:3901
      - garage_rpc_bind_addr=0.0.0.0:3902
      - garage_seed=garage1:3902
    volumes:
      - ./data/garage3:/var/lib/garage

// garage的java客户端示例
public class garageexample {
    // garage完全兼容s3 api，可以直接使用aws sdk
    private amazons3 garageclient;
    public void initgarageconnection() {
        // garage的配置与minio非常相似
        awscredentials credentials = new basicawscredentials(
            "gk...",  // garage生成的访问密钥
            "..."     // 对应的秘密密钥
        );
        garageclient = amazons3clientbuilder.standard()
            .withendpointconfiguration(
                new awsclientbuilder.endpointconfiguration(
                    "http://localhost:3900",  // garage的s3 api端口
                    "garage"  // 区域名称可自定义
                )
            )
            .withcredentials(new awsstaticcredentialsprovider(credentials))
            .withpathstyleaccessenabled(true)
            .build();
    }
    // 创建存储桶并设置策略
    public void createbucketwithpolicy(string bucketname) {
        // 创建存储桶
        garageclient.createbucket(bucketname);
        // garage支持灵活的存储策略配置
        string bucketpolicy = """
        {
            "version": "2012-10-17",
            "statement": [
                {
                    "effect": "allow",
                    "principal": "*",
                    "action": "s3:getobject",
                    "resource": "arn:aws:s3:::%s/*"
                }
            ]
        }
        """.formatted(bucketname);
        garageclient.setbucketpolicy(bucketname, bucketpolicy);
        system.out.println("存储桶创建完成，已设置公开读取策略");
    }
    // 上传文件并生成访问url
    public string uploadandgenerateurl(string bucketname, 
                                       string objectkey, 
                                       inputstream inputstream) {
        objectmetadata metadata = new objectmetadata();
        // 可以在这里设置内容类型等元数据
        metadata.setcontenttype("application/octet-stream");
        putobjectrequest request = new putobjectrequest(
            bucketname, objectkey, inputstream, metadata
        );
        garageclient.putobject(request);
        // 生成预签名url（garage支持此功能）
        java.util.date expiration = new java.util.date();
        long exptimemillis = expiration.gettime();
        exptimemillis += 1000 * 60 * 60; // 1小时有效期
        expiration.settime(exptimemillis);
        generatepresignedurlrequest generatepresignedurlrequest = 
            new generatepresignedurlrequest(bucketname, objectkey)
                .withmethod(httpmethod.get)
                .withexpiration(expiration);
        return garageclient.generatepresignedurl(
            generatepresignedurlrequest).tostring();
    }
}

// 使用ceph的s3兼容接口（radosgw）
public class cephexample {
    private amazons3 cephclient;
    public void initcephconnection() {
        // ceph通过radosgw提供s3兼容接口
        // 配置方式与aws s3几乎完全相同
        awscredentials credentials = new basicawscredentials(
            system.getenv("ceph_access_key"),
            system.getenv("ceph_secret_key")
        );
        cephclient = amazons3clientbuilder.standard()
            .withcredentials(new awsstaticcredentialsprovider(credentials))
            .withendpointconfiguration(
                new awsclientbuilder.endpointconfiguration(
                    "http://ceph-gateway.example.com:7480",
                    ""  // ceph可以不指定区域
                )
            )
            .withpathstyleaccessenabled(true)
            .build();
    }
    // ceph的高级特性：多部分上传
    public void uploadlargefiletoceph(string bucketname, 
                                      string objectkey, 
                                      file largefile) 
                                      throws exception {
        // 初始化多部分上传
        initiatemultipartuploadrequest initrequest = 
            new initiatemultipartuploadrequest(bucketname, objectkey);
        initiatemultipartuploadresult initresponse = 
            cephclient.initiatemultipartupload(initrequest);
        string uploadid = initresponse.getuploadid();
        // 分片上传（ceph可以处理非常大的文件）
        long filesize = largefile.length();
        long partsize = 100 * 1024 * 1024; // 100mb分片
        long byteposition = 0;
        list<partetag> partetags = new arraylist<>();
        int partnumber = 1;
        try (fileinputstream fis = new fileinputstream(largefile)) {
            while (byteposition < filesize) {
                long currentpartsize = math.min(partsize, filesize - byteposition);
                uploadpartrequest uploadrequest = new uploadpartrequest()
                    .withbucketname(bucketname)
                    .withkey(objectkey)
                    .withuploadid(uploadid)
                    .withpartnumber(partnumber)
                    .withinputstream(fis)
                    .withpartsize(currentpartsize);
                uploadpartresult uploadresult = cephclient.uploadpart(uploadrequest);
                partetags.add(uploadresult.getpartetag());
                byteposition += currentpartsize;
                partnumber++;
            }
            // 完成上传
            completemultipartuploadrequest comprequest = 
                new completemultipartuploadrequest(
                    bucketname, objectkey, uploadid, partetags);
            cephclient.completemultipartupload(comprequest);
        } catch (exception e) {
            // 发生错误时中止上传
            cephclient.abortmultipartupload(
                new abortmultipartuploadrequest(bucketname, objectkey, uploadid));
            throw e;
        }
    }
    // ceph特有的功能：获取存储使用情况
    public void checkcephusage() {
        // 注意：ceph不通过s3 api提供使用统计
        // 需要通过管理api或命令行获取
        system.out.println("ceph使用统计需通过以下方式获取：");
        system.out.println("1. 命令行: ceph df");
        system.out.println("2. 管理api: /api/auth");
        system.out.println("3. dashboard: 内置web界面");
    }
}

#!/bin/bash
# glusterfs 3节点集群快速部署脚本
# 在三个节点上执行类似命令
# 节点1:
gluster peer probe node2
gluster peer probe node3
# 创建分布式卷（数据分散在所有节点）
gluster volume create gv0 disperse 3 node1:/data/brick1 node2:/data/brick1 node3:/data/brick1
# 或创建复制卷（数据在所有节点复制）
gluster volume create gv1 replica 3 node1:/data/brick2 node2:/data/brick2 node3:/data/brick2
# 启动卷
gluster volume start gv0
gluster volume start gv1
# 在客户端挂载
mount -t glusterfs node1:/gv0 /mnt/glusterfs

// 通过标准的java文件api访问glusterfs
public class glusterfsexample {
    private path glustermountpoint;
    public glusterfsexample(string mountpath) {
        this.glustermountpoint = paths.get(mountpath);
        // 验证挂载点
        if (!files.exists(glustermountpoint)) {
            throw new illegalargumentexception("glusterfs挂载点不存在: " + mountpath);
        }
        system.out.println("glusterfs挂载点: " + mountpoint.toabsolutepath());
    }
    // 写入文件 - glusterfs自动处理数据分布
    public void writefile(string filename, string content) throws ioexception {
        path filepath = glustermountpoint.resolve(filename);
        // 创建父目录（如果需要）
        if (filepath.getparent() != null) {
            files.createdirectories(filepath.getparent());
        }
        // 写入文件
        files.write(filepath, 
                   content.getbytes(standardcharsets.utf_8),
                   standardopenoption.create,
                   standardopenoption.write,
                   standardopenoption.truncate_existing);
        system.out.println("文件已写入glusterfs: " + filepath);
    }
    // 读取文件
    public string readfile(string filename) throws ioexception {
        path filepath = glustermountpoint.resolve(filename);
        if (files.exists(filepath)) {
            byte[] content = files.readallbytes(filepath);
            return new string(content, standardcharsets.utf_8);
        }
        return null;
    }
    // 列出目录内容
    public list<string> listfiles(string directory) throws ioexception {
        path dirpath = glustermountpoint.resolve(directory);
        if (files.exists(dirpath) && files.isdirectory(dirpath)) {
            try (stream<path> stream = files.list(dirpath)) {
                return stream
                    .filter(files::isregularfile)
                    .map(path::getfilename)
                    .map(path::tostring)
                    .collect(collectors.tolist());
            }
        }
        return collections.emptylist();
    }
    // 获取文件信息
    public void printfileinfo(string filename) throws ioexception {
        path filepath = glustermountpoint.resolve(filename);
        if (files.exists(filepath)) {
            basicfileattributes attrs = files.readattributes(
                filepath, basicfileattributes.class);
            system.out.println("文件: " + filename);
            system.out.println("大小: " + attrs.size() + " 字节");
            system.out.println("创建时间: " + attrs.creationtime());
            system.out.println("修改时间: " + attrs.lastmodifiedtime());
            system.out.println("访问时间: " + attrs.lastaccesstime());
        }
    }
}

# 简化的swift集群配置示例
# swift.conf - 主要配置文件
[swift-hash]
# 随机hash种子，集群中所有节点必须相同
swift_hash_path_prefix = changeme
swift_hash_path_suffix = changeme
[storage-policy:0]
name = policy-0
default = yes
# ring文件 - 数据分布配置
# 使用swift-ring-builder工具管理
$ swift-ring-builder account.builder create 10 3 24
$ swift-ring-builder container.builder create 10 3 24
$ swift-ring-builder object.builder create 10 3 24
# 添加存储节点
$ swift-ring-builder object.builder add r1z1-127.0.0.1:6010/sdb1 100
$ swift-ring-builder object.builder rebalance

// 使用jclouds库访问openstack swift
public class swiftexample {
    private blobstore blobstore;
    public void initswiftconnection() {
        // 配置swift连接
        properties overrides = new properties();
        overrides.setproperty("jclouds.swift.auth.version", "3");
        // swift支持多种认证方式
        swiftapi swiftapi = contextbuilder.newbuilder("openstack-swift")
            .endpoint("http://swift.example.com:5000/v3")
            .credentials("project:username", "password")
            .overrides(overrides)
            .buildapi(swiftapi.class);
        blobstore = swiftapi.getblobstore("regionone");
    }
    // 上传对象到swift
    public string uploadtoswift(string containername, 
                                string objectname, 
                                inputstream data, 
                                long size) {
        // 确保容器存在
        if (!blobstore.containerexists(containername)) {
            blobstore.createcontainerinlocation(null, containername);
        }
        // 创建blob对象
        blob blob = blobstore.blobbuilder(objectname)
            .payload(data)
            .contentlength(size)
            .contenttype("application/octet-stream")
            .build();
        // 上传
        string etag = blobstore.putblob(containername, blob);
        system.out.println("对象上传成功，etag: " + etag);
        // 生成临时url（swift支持此功能）
        return generatetempurl(containername, objectname);
    }
    private string generatetempurl(string container, string object) {
        // swift支持通过临时url共享对象
        // 这里需要swift集群配置了临时url密钥
        long expires = system.currenttimemillis() / 1000 + 3600; // 1小时后过期
        // 临时url生成逻辑（实际实现更复杂）
        return string.format(
            "http://swift.example.com:8080/v1/auth_%s/%s/%s?temp_url_sig=xxx&temp_url_expires=%d",
            "account", container, object, expires
        );
    }
    // 大对象分片上传（swift称为"静态大对象"）
    public void uploadlargeobject(string container, 
                                  string objectname, 
                                  list<file> segments) {
        // 上传所有分片
        list<string> segmentpaths = new arraylist<>();
        for (int i = 0; i < segments.size(); i++) {
            string segmentname = string.format("%s/%08d", objectname, i);
            try (inputstream is = new fileinputstream(segments.get(i))) {
                uploadtoswift(container, segmentname, is, segments.get(i).length());
                segmentpaths.add(string.format("/%s/%s", container, segmentname));
            } catch (ioexception e) {
                throw new runtimeexception("分片上传失败", e);
            }
        }
        // 创建清单文件
        string manifest = string.join("\n", segmentpaths);
        try (inputstream is = new bytearrayinputstream(manifest.getbytes())) {
            blobstore.putblob(container, 
                blobstore.blobbuilder(objectname)
                    .payload(is)
                    .contentlength(manifest.length())
                    .contenttype("text/plain")
                    .build());
        } catch (ioexception e) {
            throw new runtimeexception("清单文件创建失败", e);
        }
        system.out.println("大对象上传完成，共 " + segments.size() + " 个分片");
    }
}