分布式存储：GFS/HDFS/Ceph/MinIO架构

GFS/HDFS主从架构

GFS（Google File System）和HDFS（Hadoop Distributed File System）采用经典的主从架构。NameNode（Master）管理元数据和命名空间，DataNode（Slave）存储实际数据块。

┌─────────────┐     ┌─────────────┐
│   Client    │────▶│  NameNode   │  元数据管理
└─────────────┘     └─────────────┘
      │                    │
      ▼                    ▼
┌─────────────┐     ┌─────────────┐
│  DataNode 1 │     │  DataNode 2 │  数据存储
└─────────────┘     └─────────────┘

// HDFS客户端写入流程
public class HDFSClient {
    private DistributedFileSystem dfs;
    
    public void writeFile(String path, byte[] data) throws IOException {
        // 1. 向NameNode请求创建文件
        FSDataOutputStream out = dfs.create(new Path(path));
        
        // 2. 数据以Block为单位写入（默认128MB）
        out.write(data);
        out.close();
        
        // 3. NameNode将Block分配到多个DataNode
        // 4. 确认写入完成后返回客户端
    }
    
    // 副本放置策略
    // 第一个副本：写入节点（如果是集群内）或随机节点
    // 第二个副本：不同机架的随机节点
    // 第三个副本：与第二个副本同机架的随机节点
}

Ceph CRUSH算法

Ceph使用CRUSH（Controlled Replication Under Scalable Hashing）算法实现去中心化的数据放置，无需中央查找表。

class CRUSHAlgorithm:
    def __init__(self, cluster_map: dict):
        self.cluster_map = cluster_map
    
    def map(self, pg_id: int, replication: int = 3) -> list:
        """CRUSH算法选择存储目标"""
        # 计算PG的CRUSH hash
        hash_val = self._crush_hash(pg_id)
        
        # 从根节点开始递归选择
        return self._select(self.cluster_map['root'], hash_val, replication, [])
    
    def _select(self, bucket, hash_val: int, num_replicas: int, 
                exclude: list) -> list:
        """递归选择存储目标"""
        if bucket['type'] == 'osd':
            if bucket['id'] not in exclude:
                return [bucket['id']]
            return []
        
        # 按权重排序子节点
        children = sorted(bucket['children'], key=lambda x: x['weight'], reverse=True)
        
        # 使用加权随机选择
        results = []
        for child in children:
            if len(results) >= num_replicas:
                break
            results.extend(self._select(child, hash_val, num_replicas, 
                                       exclude + results))
        
        return results[:num_replicas]
    
    def _crush_hash(self, pg_id: int) -> int:
        """CRUSH哈希函数"""
        return pg_id * 0x9e3779b9

MinIO对象存储

MinIO是高性能的S3兼容对象存储，采用纠删码（Erasure Coding）保证数据可靠性。

// MinIO纠删码配置
func createErasureSet(endpoint string) {
    // 纠删码配置
    // 数据块: 8, 校验块: 4
    // 容忍4个磁盘故障
    config := &server.Config{
        DataDir:          "/data",
        Erasure: &server.ErasureConfig{
            DataDisks:   8,
            ParityDisks: 4,
        },
    }
    
    // 对象存储流程
    // 1. 计算对象的erasure code
    // 2. 将数据分割为DataDisks块
    // 3. 生成ParityDisks个校验块
    // 4. 将所有块分布到不同磁盘
}

// 客户端上传
func uploadObject(client *minio.Client, bucket, object string, data []byte) error {
    // 自动使用纠删码
    reader := bytes.NewReader(data)
    _, err := client.PutObject(context.Background(), bucket, object, reader, int64(len(data)),
        minio.PutObjectOptions{
            ContentType: "application/octet-stream",
        })
    return err
}

存储系统对比

特性	HDFS	Ceph	MinIO
架构	主从	去中心化	分布式
数据模型	块存储	块/对象/文件	对象存储
一致性	强一致	强一致	强一致
扩展性	NameNode瓶颈	无单点	线性扩展
适用场景	大数据分析	通用存储	云原生/备份