// 假設(shè)你基于Minio開發(fā)了一個文件管理服務(wù)
public class FileManagementService {
    // 這段代碼本身可能沒問題...
    private MinioClient minioClient;
    public void processUserFile(UserFile file) {
        // 但是，如果你的整個服務(wù)基于AGPLv3代碼
        // 根據(jù)嚴格解釋，你可能需要開源整個項目
        minioClient.putObject(...);
        // 更多業(yè)務(wù)邏輯...
    }
}

# SeaweedFS的部署簡單到令人驚訝
# 1. 下載（只有一個二進制文件?。?
wget https://github.com/seaweedfs/seaweedfs/releases/download/3.55/linux_amd64.tar.gz
tar -xzf linux_amd64.tar.gz
# 2. 啟動主服務(wù)器（管理元數(shù)據(jù)）
./weed master -ip=localhost -port=9333
# 3. 啟動存儲節(jié)點
./weed volume -dir="./data" -max=100 -mserver="localhost:9333" -port=8080
# 就是這么簡單！現(xiàn)在你已經(jīng)有了一個分布式文件系統(tǒng)

// 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需要此設(shè)置
            .build();
    }
    // 上傳文件到SeaweedFS
    public void uploadFile(String bucketName, String objectKey, File file) {
        // 創(chuàng)建存儲桶（如果需要）
        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內(nèi)部會自動將小文件合并存儲
        // 這大大提高了海量小文件的存儲效率
        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會自動優(yōu)化這些文件的存儲");
    }
}

# docker-compose.yml - 3節(jié)點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生成的訪問密鑰
            "..."     // 對應(yīng)的秘密密鑰
        );
        garageClient = AmazonS3ClientBuilder.standard()
            .withEndpointConfiguration(
                new AwsClientBuilder.EndpointConfiguration(
                    "http://localhost:3900",  // Garage的S3 API端口
                    "garage"  // 區(qū)域名稱可自定義
                )
            )
            .withCredentials(new AWSStaticCredentialsProvider(credentials))
            .withPathStyleAccessEnabled(true)
            .build();
    }
    // 創(chuàng)建存儲桶并設(shè)置策略
    public void createBucketWithPolicy(String bucketName) {
        // 創(chuàng)建存儲桶
        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("存儲桶創(chuàng)建完成，已設(shè)置公開讀取策略");
    }
    // 上傳文件并生成訪問URL
    public String uploadAndGenerateUrl(String bucketName, 
                                       String objectKey, 
                                       InputStream inputStream) {
        ObjectMetadata metadata = new ObjectMetadata();
        // 可以在這里設(shè)置內(nèi)容類型等元數(shù)據(jù)
        metadata.setContentType("application/octet-stream");
        PutObjectRequest request = new PutObjectRequest(
            bucketName, objectKey, inputStream, metadata
        );
        garageClient.putObject(request);
        // 生成預(yù)簽名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可以不指定區(qū)域
                )
            )
            .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) {
            // 發(fā)生錯誤時中止上傳
            cephClient.abortMultipartUpload(
                new AbortMultipartUploadRequest(bucketName, objectKey, uploadId));
            throw e;
        }
    }
    // Ceph特有的功能：獲取存儲使用情況
    public void checkCephUsage() {
        // 注意：Ceph不通過S3 API提供使用統(tǒng)計
        // 需要通過管理API或命令行獲取
        System.out.println("Ceph使用統(tǒng)計需通過以下方式獲取：");
        System.out.println("1. 命令行: ceph df");
        System.out.println("2. 管理API: /api/auth");
        System.out.println("3. Dashboard: 內(nèi)置Web界面");
    }
}

#!/bin/bash
# GlusterFS 3節(jié)點集群快速部署腳本
# 在三個節(jié)點上執(zhí)行類似命令
# 節(jié)點1:
gluster peer probe node2
gluster peer probe node3
# 創(chuàng)建分布式卷（數(shù)據(jù)分散在所有節(jié)點）
gluster volume create gv0 disperse 3 node1:/data/brick1 node2:/data/brick1 node3:/data/brick1
# 或創(chuàng)建復(fù)制卷（數(shù)據(jù)在所有節(jié)點復(fù)制）
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自動處理數(shù)據(jù)分布
    public void writeFile(String filename, String content) throws IOException {
        Path filePath = glusterMountPoint.resolve(filename);
        // 創(chuàng)建父目錄（如果需要）
        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;
    }
    // 列出目錄內(nèi)容
    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() + " 字節(jié)");
            System.out.println("創(chuàng)建時間: " + attrs.creationTime());
            System.out.println("修改時間: " + attrs.lastModifiedTime());
            System.out.println("訪問時間: " + attrs.lastAccessTime());
        }
    }
}

# 簡化的Swift集群配置示例
# swift.conf - 主要配置文件
[swift-hash]
# 隨機hash種子，集群中所有節(jié)點必須相同
swift_hash_path_prefix = changeme
swift_hash_path_suffix = changeme
[storage-policy:0]
name = Policy-0
default = yes
# ring文件 - 數(shù)據(jù)分布配置
# 使用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
# 添加存儲節(jié)點
$ 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);
        }
        // 創(chuàng)建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生成邏輯（實際實現(xiàn)更復(fù)雜）
        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稱為"靜態(tài)大對象"）
    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);
            }
        }
        // 創(chuàng)建清單文件
        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("清單文件創(chuàng)建失敗", e);
        }
        System.out.println("大對象上傳完成，共 " + segments.size() + " 個分片");
    }
}