大模型基石 AI 分布式存储工程实战（完结）

┌──────────────────────────────────────────────────────┐
│                  第一层：热数据层                      │
│        当前训练batch / 推理请求 / 实时特征              │
│        技术：GooseFS(本地缓存) + Redis + GPU显存        │
│        要求：亚毫秒延迟，GB/s级吞吐                      │
├──────────────────────────────────────────────────────┤
│                  第二层：温数据层                      │
│        Checkpoint / 近期向量索引 / 活跃知识库           │
│        技术：CFS(腾讯云文件存储) + Milvus/Weaviate     │
│        要求：10GB/s级吞吐，强一致性，POSIX兼容          │
├──────────────────────────────────────────────────────┤
│                  第三层：冷数据层                      │
│        历史训练数据 / 全量向量库 / 原始语料              │
│        技术：COS(对象存储) + Data Lake Compute          │
│        要求：PB级容量，低成本，高耐久(11个9)             │
├──────────────────────────────────────────────────────┤
│                  第四层：元数据层                      │
│        实验记录 / 模型版本 / 数据血缘 / 权限审计          │
│        技术：TDSQL-C(云原生数据库) + Elasticsearch     │
│        要求：强事务，可检索，可追溯                       │
└──────────────────────────────────────────────────────┘

                    ┌─────────────┐
                    │   TI-ONE    │  训练调度
                    └──────┬──────┘
                           │
              ┌────────────┼────────────┐
              ▼            ▼            ▼
        ┌──────────┐ ┌──────────┐ ┌──────────┐
        │ GooseFS  │ │   CFS    │ │   COS    │
        │ (热数据)  │ │ (温数据)  │ │ (冷数据)  │
        │ 本地NVMe │ │ 多节点NFS│ │ 对象存储  │
        │ 10GB/s   │ │ 100GB/s  │ │ PB级     │
        └────┬─────┘ └────┬─────┘ └────┬─────┘
             │            │            │
             └────────────┼────────────┘
                          ▼
                   ┌─────────────┐
                   │  TDSQL-C    │  元数据/实验管理
                   └─────────────┘

bash# GooseFS挂载到训练节点
goosefs://your-bucket.cos.ap-beijing.myqcloud.com/train-data \
  /mnt/goosefs \
  fuse.goosefs \
  url=your-bucket.cos.ap-beijing.myqcloud.com,\
  token=your-token,\
  local_cache=/data/nvme/goosefs-cache,\
  cache_size=500G,\
  prefetch=true 0 0

bash# 所有训练节点挂载同一CFS，存checkpoint
your-cfs-id.cfs.ap-beijing.myqcloud.com:/ /mnt/cfs nfs4 \
  nfsvers=4.1,rsize=1048576,wsize=1048576,hard,timeo=600,retrans=2 0 0

┌──────────────┐     ┌──────────────────┐     ┌─────────────┐
│   业务应用    │────▶│ 腾讯云向量数据库   │────▶│    COS      │
│  (提问/检索)  │     │  (热向量: 近30天)  │     │ (冷向量归档) │
└──────────────┘     │  IVF_FLAT索引     │     │  生命周期    │
                     │  P99<30ms         │     │  自动迁移    │
                     └──────────────────┘     └─────────────┘

java@Service
public class RagVectorService {

    @Autowired
    private VectorStore vectorStore; // 腾讯云向量数据库SDK

    /**
     * 写入文档向量
     */
    public void ingest(List<Document> documents) {
        List<Embedding> embeddings = embeddingModel.embed(
            documents.stream().map(Document::content).toList()
        );
        
        List<VectorStoreRecord> records = IntStream.range(0, documents.size())
            .mapToObj(i -> VectorStoreRecord.builder()
                .id(documents.get(i).getId())
                .vector(embeddings.get(i).getValues())
                .metadata(Map.of(
                    "content", documents.get(i).getContent(),
                    "source", documents.get(i).getSource(),
                    "created_at", Instant.now().toString()
                ))
                .build())
            .toList();
        
        vectorStore.add(records); // 批量写入，自动分片
    }

    /**
     * 语义检索
     */
    public List<Document> search(String query, int topK) {
        Embedding queryEmbedding = embeddingModel.embed(query);
        
        List<VectorStoreRecord> results = vectorStore.similaritySearch(
            SimilarityMetric.COSINE,
            queryEmbedding.getValues(),
            topK
        );
        
        return results.stream()
            .map(r -> new Document(
                r.getMetadata().get("content").toString(),
                Map.of("score", r.getScore(), "source", r.getMetadata().get("source"))
            ))
            .toList();
    }
}

python# 训练脚本中集成（PyTorch + 腾讯云CFS）
import tensorflow as tf
from goosefs import GooseFSClient

class CheckpointManager:
    def __init__(self, cfs_path="/mnt/cfs/checkpoints"):
        self.cfs_path = cfs_path
        self.last_save = time.time()
        self.best_loss = float('inf')
    
    def save(self, model, optimizer, step, loss):
        # 定时保存
        if time.time() - self.last_save > 1800:  # 30min
            self._do_save(model, optimizer, step, loss)
            return
        
        # loss突变保存（防止训练崩了白跑）
        if loss < self.best_loss * 0.95:
            self._do_save(model, optimizer, step, loss)
            self.best_loss = loss
    
    def _do_save(self, model, optimizer, step, loss):
        # 异步保存到CFS，不阻塞训练
        torch.save({
            'step': step,
            'model': model.state_dict(),
            'optimizer': optimizer.state_dict(),
            'loss': loss,
        }, f"{self.cfs_path}/ckpt_step{step}.pt")
        self.last_save = time.time()
        print(f"Checkpoint saved: step={step}, loss={loss:.4f}")

训练中断
    │
    ▼
检测到最新checkpoint（CFS上 step=125000）
    │
    ▼
从CFS拉取checkpoint → GooseFS本地缓存（加速）
    │
    ▼
恢复optimizer状态 + learning rate scheduler状态
    │
    ▼
从step=125001继续训练
    │
    ▼
训练日志写入TDSQL-C（可追溯）