使用 gRPC 双向流构建高性能文件传输服务

mrkong

背景与动机

在微服务架构下，服务之间传输大文件（如日志包、备份数据、模型文件等）是一项常见但挑战性较强的任务。传统的 HTTP 上传方式存在以下问题：

• 大文件上传耗时长，阻塞线程
• 不具备天然的断点续传能力
• 传输过程中容易因网络抖动中断
  

为了解决这些问题，我们选择使用 gRPC 双向流（bidirectional streaming） 来实现更高效、更可控的文件传输机制。

为什么选择 gRPC Streaming？gRPC 是基于 HTTP/2 的高性能 RPC 框架，具备如下优势：

• 双向流传输：支持客户端和服务端并发传输数据块
• 内置连接管理、重试、压缩：提高稳定性
• 二进制协议（protobuf）：高效、易扩展
• 天然适配微服务通信场景
  

系统设计概览基本流程

• 客户端读取大文件，分块传输到服务端
• 服务端接收块数据并按顺序写入本地临时文件
• 支持进度回传、失败重试、文件完整性校验（SHA256）
  

protobuf 定义

1. syntax = "proto3";
   
2. 
   
3. service FileTransfer {
   
4.   rpc Upload(stream FileChunk) returns (UploadStatus);
   
5. }
   
6. 
   
7. message FileChunk {
   
8.   string filename = 1;
   
9.   bytes content = 2;
   
10.   int64 offset = 3;
    
11.   bool eof = 4;
    
12.   string sha256 = 5;
    
13. }
    
14. 
    
15. message UploadStatus {
    
16.   bool success = 1;
    
17.   string message = 2;
    
18. }

复制代码

服务端实现（Go）

1. func (s *Server) Upload(stream pb.FileTransfer_UploadServer) error {
   
2.     var file *os.File
   
3.     var filename string
   
4.     var hasher = sha256.New()
   
5. 
   
6.     for {
   
7.         chunk, err := stream.Recv()
   
8.         if err == io.EOF {
   
9.             // 写入完成，校验 hash
   
10.             calculated := hex.EncodeToString(hasher.Sum(nil))
    
11.             if calculated != expectedHash {
    
12.                 return stream.SendAndClose(&pb.UploadStatus{
    
13.                     Success: false,
    
14.                     Message: "SHA256 mismatch",
    
15.                 })
    
16.             }
    
17.             return stream.SendAndClose(&pb.UploadStatus{
    
18.                 Success: true,
    
19.                 Message: "Upload complete",
    
20.             })
    
21.         }
    
22.         if err != nil {
    
23.             return err
    
24.         }
    
25. 
    
26.         if file == nil {
    
27.             filename = chunk.Filename
    
28.             file, err = os.Create("/tmp/" + filename)
    
29.             if err != nil {
    
30.                 return err
    
31.             }
    
32.             defer file.Close()
    
33.         }
    
34. 
    
35.         file.WriteAt(chunk.Content, chunk.Offset)
    
36.         hasher.Write(chunk.Content)
    
37.     }
    
38. }

复制代码

客户端实现（Go）

1. stream, err := client.Upload(context.Background())
   
2. if err != nil {
   
3.     log.Fatal(err)
   
4. }
   
5. 
   
6. buf := make([]byte, 1024*1024) // 1MB block
   
7. var offset int64
   
8. file, _ := os.Open("large_file.zip")
   
9. defer file.Close()
   
10. 
    
11. h := sha256.New()
    
12. 
    
13. for {
    
14.     n, err := file.Read(buf)
    
15.     if err == io.EOF {
    
16.         break
    
17.     }
    
18.     h.Write(buf[:n])
    
19. 
    
20.     chunk := &pb.FileChunk{
    
21.         Filename: "large_file.zip",
    
22.         Content:  buf[:n],
    
23.         Offset:   offset,
    
24.         Sha256:   "", // 可在最后一块填入完整值
    
25.     }
    
26.     offset += int64(n)
    
27.     stream.Send(chunk)
    
28. }
    
29. 
    
30. // 最后一块带 eof=true 和 sha256 值
    
31. stream.Send(&pb.FileChunk{
    
32.     Filename: "large_file.zip",
    
33.     Content:  nil,
    
34.     Offset:   offset,
    
35.     Sha256:   hex.EncodeToString(h.Sum(nil)),
    
36.     Eof:      true,
    
37. })
    
38. 
    
39. res, err := stream.CloseAndRecv()
    
40. log.Println("Upload result:", res.Message)

复制代码

性能与可靠性优化建议

方向	建议
并发传输	多文件同时传输可开多连接并发
压缩算法	传输前压缩（如 gzip）降低带宽占用
中断恢复	记录 offset，失败后从断点续传
限流保护	gRPC 配置并发数和带宽限速

总结

使用 gRPC 双向流传输大文件具有高效、稳定、可控的优点。相比传统 HTTP 上传，它适合微服务体系内的大规模数据同步、备份、模型分发等场景。未来也可以进一步结合传输调度、服务发现机制，实现跨集群传输任务自动调度。

如果你在项目中有大文件传输需求，gRPC streaming 是值得尝试的解决方案之一。