Go语言中限制Box API上传请求带宽的问题排查

你的实现存在三个核心问题，导致带宽限流完全失效：

问题分析 #

1. 未使用全局共享的限流桶
   每个分块上传请求（包括重试）都创建了独立的ratelimit.Bucket，多个worker或分块任务的流量不受全局限制，总带宽会是所有分块的速率叠加，完全达不到全局限流的目的。

2. 预加载分块到内存后再限流
   你先把整个分块读入内存buffer，再用bytes.NewReader包装后套限流Reader。由于内存读取速度远超过限流阈值，限流Reader无法控制实际上传速度——HTTP客户端会瞬间把内存中的数据发送出去，限流逻辑形同虚设。

3. 限流参数不符合预期
   代码中每个独立桶设置的是1MB/s，但你预期的是全局6MB/s，即使共享桶，参数也需要对应调整。

解决方案 #

1. 创建全局共享的限流桶 #

在BoxModule结构体中添加全局限流桶，所有上传任务共用这个桶，确保总带宽不超过阈值：

type BoxModule struct {
    // ... 原有字段
    uploadRateLimit *ratelimit.Bucket
}

// 初始化时创建全局限流桶（示例为6MB/s）
func NewBoxModule() *BoxModule {
    return &BoxModule{
        // ... 其他初始化逻辑
        uploadRateLimit: ratelimit.NewBucketWithRate(6*1024*1024, 6*1024*1024),
    }
}

2. 直接对文件读取做限流 #

去掉内存预加载逻辑，直接用限流Reader包装文件句柄，配合io.LimitReader控制分块读取范围：

func (bm *BoxModule) uploadChunkedFilePart(uploadSessionID string, path string, start int64, stop int64, total int64) {
    file, err := os.Open(path)
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    chunkSize := stop - start + 1
    if chunkSize < 0 {
        log.Fatalf("Invalid buffer size for file %s: start = %d, stop = %d", path, start, stop)
    }

    // 先定位文件指针并计算分块SHA1（不能用限流Reader计算哈希，避免拖慢速度）
    _, err = file.Seek(start, io.SeekStart)
    if err != nil {
        log.Fatal(err)
    }
    hashBuf := make([]byte, chunkSize)
    _, err = file.Read(hashBuf)
    if err != nil && err != io.EOF {
        log.Fatal(err)
    }
    // 计算哈希后重新定位到分块起始位置
    _, err = file.Seek(start, io.SeekStart)
    if err != nil {
        log.Fatal(err)
    }

    hasher := sha1.New()
    hasher.Write(hashBuf)
    sha := base64.StdEncoding.EncodeToString(hasher.Sum(nil))

    maxRetryAttempts := 3
    keyIndex := bm.ChunkedUploads[uploadSessionID].KeyIndex

    for attempt := 1; attempt <= maxRetryAttempts; attempt++ {
        // 1. 限制读取范围为当前分块
        limitedFile := io.LimitReader(file, chunkSize)
        // 2. 用全局共享桶包装reader，控制读取速度
        rateLimitedReader := ratelimit.Reader(limitedFile, bm.uploadRateLimit)

        req, err := http.NewRequest("PUT", "https://upload.box.com/api/2.0/files/upload_sessions/"+uploadSessionID, rateLimitedReader)
        if err != nil {
            log.Fatal(err)
        }

        req.Header.Set("Authorization", "Bearer "+bm.getKey(keyIndex))
        req.Header.Set("Digest", "sha="+sha)
        req.Header.Set("Content-Range", fmt.Sprintf("bytes %d-%d/%d", start, stop, total))
        req.Header.Set("Content-Type", "application/octet-stream")

        resp, err := bm.client.Do(req)
        if err != nil {
            log.Fatal(err)
        }
        defer resp.Body.Close()

        bodyBytes, err := ioutil.ReadAll(resp.Body)
        if err != nil {
            log.Fatal(err)
        }
        bodyString := string(bodyBytes)

        // ... 原有响应处理和重试逻辑 ...
    }
}

补充说明 #

• 全局桶确保所有上传任务的总带宽严格控制在设定阈值内，不受worker数量或分块数量影响。
• 直接对文件句柄限流，HTTP客户端会按需从限流Reader中读取数据，读取速度被桶限制，从而真正控制上传带宽。
• 哈希计算单独读取分块内容，避免限流逻辑拖慢哈希生成速度。

内容的提问来源于stack exchange，提问作者CaffeineAddiction