使用Go SDK v2从AWS S3下载大文件的优化方案咨询

我需要实现从AWS S3下载大文件的功能，参考AWS文档及示例后编写了如下代码：

func (b *biz) S3DownloadFile(ctx context.Context, key string) ([]byte, error) {
    downloader := manager.NewDownloader(b.s3client, func(d *manager.Downloader) {
        d.PartSize = 5 * 1024 * 1024 // 5MB parts
    })
    buffer := manager.NewWriteAtBuffer([]byte{})
    _, err := downloader.Download(ctx, buffer, &s3.GetObjectInput{
        Bucket: &b.bucketName,
        Key:    &key,
    })
    if err != nil {
        log.Printf("Error downloading file: %v", err)
        return nil, err
    }
    return buffer.Bytes(), err
}

客户端通过调用该API获取文件数据后，创建隐藏的<a>标签并自动点击以触发下载。

当前问题 #

针对大文件，当前方案会将所有分片加载至内存后再发送给客户端，导致客户端等待时间过长。

目标 #

我希望实现类似预签名URL的效果：点击链接后文件流式下载，用户可直观看到下载进度。

现有思路 #

目前考虑两种解决方案：

• 使用预签名URL：可实现需求，但可控性不足
• 基于现有downloader的io.WriterAt接口，编写自定义Writer处理流式传输

除上述方案外，是否有更优的实现方式？望赐教。

方案1：直接流式转发S3对象到客户端（推荐） #

无需使用manager.Downloader，直接调用S3的GetObject接口获取响应流，再将流实时转发给客户端。这种方式边下载边传输，完全不占用内存缓存大文件，客户端能立即看到下载进度。

示例代码（假设API基于HTTP响应Writer实现）：

func (b *biz) S3StreamDownload(ctx context.Context, key string, w http.ResponseWriter) error {
    resp, err := b.s3client.GetObject(ctx, &s3.GetObjectInput{
        Bucket: &b.bucketName,
        Key:    &key,
    })
    if err != nil {
        log.Printf("Error getting S3 object: %v", err)
        return err
    }
    defer resp.Body.Close()

    // 设置响应头，让浏览器识别为下载文件
    w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", filepath.Base(key)))
    w.Header().Set("Content-Type", aws.ToString(resp.ContentType))
    w.Header().Set("Content-Length", aws.ToString(resp.ContentLength))

    // 流式复制到响应Writer，实现边下载边传输
    _, err = io.Copy(w, resp.Body)
    if err != nil {
        log.Printf("Error streaming file to client: %v", err)
        return err
    }
    return nil
}

该方案优势：

• 内存占用极低，适配超大文件下载
• 客户端无等待延迟，实时显示下载进度
• 可控性强，可在转发流程中添加鉴权、日志、限流等自定义逻辑

方案2：优化自定义io.WriterAt实现 #

如果必须保留manager.Downloader的分片下载能力（比如需要断点续传），可以实现自定义WriterAt，将分片数据实时写入HTTP响应流：

type StreamWriterAt struct {
    w   http.ResponseWriter
    pos int64
    mu  sync.Mutex
}

func NewStreamWriterAt(w http.ResponseWriter) *StreamWriterAt {
    return &StreamWriterAt{w: w}
}

func (sw *StreamWriterAt) WriteAt(p []byte, off int64) (n int, err error) {
    sw.mu.Lock()
    defer sw.mu.Unlock()

    // 防御性检查，确保写入顺序符合S3分片下载的顺序特性
    if off != sw.pos {
        return 0, fmt.Errorf("unexpected write offset: expected %d, got %d", sw.pos, off)
    }

    n, err = sw.w.Write(p)
    sw.pos += int64(n)
    // 强制刷新响应，确保数据立即发送到客户端
    if flusher, ok := sw.w.(http.Flusher); ok {
        flusher.Flush()
    }
    return n, err
}

使用该Writer的下载逻辑：

func (b *biz) S3DownloadFileStream(ctx context.Context, key string, w http.ResponseWriter) error {
    // 先获取文件元信息，设置响应头
    headResp, err := b.s3client.HeadObject(ctx, &s3.HeadObjectInput{
        Bucket: &b.bucketName,
        Key:    &key,
    })
    if err != nil {
        return err
    }

    w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", filepath.Base(key)))
    w.Header().Set("Content-Type", aws.ToString(headResp.ContentType))
    w.Header().Set("Content-Length", fmt.Sprintf("%d", headResp.ContentLength))

    downloader := manager.NewDownloader(b.s3client, func(d *manager.Downloader) {
        d.PartSize = 5 * 1024 * 1024 // 5MB parts
    })
    sw := NewStreamWriterAt(w)
    _, err = downloader.Download(ctx, sw, &s3.GetObjectInput{
        Bucket: &b.bucketName,
        Key:    &key,
    })
    if err != nil {
        log.Printf("Error downloading file: %v", err)
        return err
    }
    return nil
}

该方案保留了分片下载特性，同时实现流式传输，但复杂度高于直接转发流。

方案对比 #

• 直接转发S3响应流：最简单高效，内存占用最低，优先推荐
• 自定义WriterAt：适合需要分片下载特性的场景
• 预签名URL：适合无中间层处理需求的场景，但可控性弱，无法添加自定义逻辑

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